Cataclysm BN
game Class Reference

#include <game.h>

Classes

class  Creature_range
 
class  debug_hour_timer
 
class  draw_callback_t
 
class  monster_range
 
class  non_dead_range
 
class  npc_range
 

Public Types

enum  inventory_item_menu_positon { RIGHT_TERMINAL_EDGE , LEFT_OF_INFO , RIGHT_OF_INFO , LEFT_TERMINAL_EDGE }
 

Public Member Functions

 game ()
 
 ~game ()
 
void load_static_data ()
 Loads static data that does not depend on mods or similar. More...
 
void load_core_data (loading_ui &ui)
 Loads core dynamic data. More...
 
bool is_core_data_loaded () const
 Returns whether the core data is currently loaded. More...
 
bool check_mod_data (const std::vector< mod_id > &opts, loading_ui &ui)
 Check if mods can be successfully loaded. More...
 
void load_world_modfiles (loading_ui &ui)
 Loads core data and mods from the active world. More...
 
std::string get_player_base_save_path () const
 Base path for saving player data. More...
 
std::string get_world_base_save_path () const
 Base path for saving world data. More...
 
bool load_packs (const std::string &msg, const std::vector< mod_id > &packs, loading_ui &ui)
 Load content packs. More...
 
void on_options_changed ()
 Should be invoked whenever options change. More...
 
void setup ()
 
void serialize (std::ostream &fout)
 Saving and loading functions. More...
 
void unserialize (std::istream &fin)
 
void unserialize_master (std::istream &fin)
 
bool dump_stats (const std::string &what, dump_mode mode, const std::vector< std::string > &opts)
 write statistics to stdout and More...
 
bool save ()
 Returns false if saving failed. More...
 
std::vector< std::string > list_active_characters ()
 Returns a list of currently active character saves. More...
 
void write_memorial_file (const std::string &filename, std::string sLastWords)
 Writes information about the character out to a text file timestamped with the time of the file was made. More...
 
bool cleanup_at_end ()
 
void start_calendar ()
 
bool do_turn ()
 MAIN GAME LOOP. More...
 
shared_ptr_fast< ui_adaptorcreate_or_get_main_ui_adaptor ()
 
void invalidate_main_ui_adaptor () const
 
void mark_main_ui_adaptor_resize () const
 
void draw ()
 
void draw_ter (bool draw_sounds=true)
 
void draw_ter (const tripoint &center, bool looking=false, bool draw_sounds=true)
 
void add_draw_callback (shared_ptr_fast< draw_callback_t > cb)
 
void draw_panels (bool force_draw=false)
 
cata::optional< tripointget_veh_dir_indicator_location (bool next) const
 Returns the location where the indicator should go relative to the reality bubble, or nothing to indicate no indicator should be drawn. More...
 
void draw_veh_dir_indicator (bool next)
 
void vertical_move (int z, bool force, bool peeking=false)
 Moves the player vertically. More...
 
void start_hauling (const tripoint &pos)
 
cata::optional< tripointfind_or_make_stairs (map &mp, int z_after, bool &rope_ladder, bool peeking)
 Returns the other end of the stairs (if any). More...
 
void vertical_shift (int z_after)
 Actual z-level movement part of vertical_move. More...
 
void vertical_notes (int z_before, int z_after)
 Add goes up/down auto_notes (if turned on) More...
 
void use_computer (const tripoint &p)
 Checks to see if a player can use a computer (not illiterate, etc.) and uses if able. More...
 
template<typename T = Creature>
T * critter_by_id (const character_id &id)
 
template<typename T = Creature>
T * critter_at (const tripoint &p, bool allow_hallucination=false)
 Returns the Creature at the given location. More...
 
template<typename T = Creature>
const T * critter_at (const tripoint &p, bool allow_hallucination=false) const
 
template<typename T = Creature>
shared_ptr_fast< T > shared_from (const T &critter)
 Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature). More...
 
size_t num_creatures () const
 Returns the approximate number of creatures in the reality bubble. More...
 
bool update_zombie_pos (const monster &critter, const tripoint &pos)
 Redirects to the creature_tracker update_pos() function. More...
 
void remove_zombie (const monster &critter)
 
void clear_zombies ()
 Redirects to the creature_tracker clear() function. More...
 
bool spawn_hallucination (const tripoint &p)
 Spawns a hallucination at a determined position. More...
 
bool swap_critters (Creature &, Creature &)
 Swaps positions of two creatures. More...
 
Creature_range all_creatures ()
 Returns an anonymous range that contains all creatures. More...
 
monster_range all_monsters ()
 Same as all_creatures but iterators only over monsters. More...
 
npc_range all_npcs ()
 Same as all_creatures but iterators only over npcs. More...
 
std::vector< Creature * > get_creatures_if (const std::function< bool(const Creature &)> &pred)
 Returns all creatures matching a predicate. More...
 
std::vector< npc * > get_npcs_if (const std::function< bool(const npc &)> &pred)
 
Creatureget_creature_if (const std::function< bool(const Creature &)> &pred)
 Returns a creature matching a predicate. More...
 
bool is_empty (const tripoint &p)
 Returns true if there is no player, NPC, or monster on the tile and move_cost > 0. More...
 
bool is_in_sunlight (const tripoint &p)
 Returns true if p is outdoors and it is sunny. More...
 
bool is_sheltered (const tripoint &p)
 Returns true if p is indoors, underground, or in a car. More...
 
bool revive_corpse (const tripoint &p, item &it)
 Revives a corpse at given location. More...
 
void save_cyborg (item *cyborg, const tripoint &couch_pos, player &installer)
 Turns Broken Cyborg monster into Cyborg NPC via surgery. More...
 
bool cancel_activity_query (const std::string &text)
 Asks if the player wants to cancel their activity, and if so cancels it. More...
 
bool cancel_activity_or_ignore_query (distraction_type type, const std::string &text)
 Asks if the player wants to cancel their activity and if so cancels it. More...
 
void moving_vehicle_dismount (const tripoint &dest_loc)
 Handles players exiting from moving vehicles. More...
 
vehicleremoteveh ()
 Returns the current remotely controlled vehicle. More...
 
void setremoteveh (vehicle *veh)
 Sets the current remotely controlled vehicle. More...
 
int assign_mission_id ()
 Returns the next available mission id. More...
 
npcfind_npc (character_id id)
 Find the npc with the given ID. More...
 
void load_npcs ()
 Makes any nearby NPCs on the overmap active. More...
 
void reload_npcs ()
 Unloads, then loads the NPCs. More...
 
const kill_trackerget_kill_tracker () const
 
void add_npc_follower (const character_id &id)
 Add follower id to set of followers. More...
 
void remove_npc_follower (const character_id &id)
 Remove follower id from follower set. More...
 
std::set< character_idget_follower_list ()
 Get set of followers. More...
 
void validate_npc_followers ()
 validate list of followers to account for overmap buffers More...
 
void validate_mounted_npcs ()
 
void validate_linked_vehicles ()
 validate towed vehicles so they get linked up again after a load More...
 
void validate_camps ()
 validate camps to ensure they are on the overmap list More...
 
void autopilot_vehicles ()
 process vehicles that are following the player More...
 
void catch_a_monster (monster *fish, const tripoint &pos, player *p, const time_duration &catch_duration)
 Picks and spawns a random fish from the remaining fish list when a fish is caught. More...
 
std::unordered_set< tripointget_fishable_locations (int distance, const tripoint &fish_pos)
 Get the contiguous fishable locations starting at fish_pos, out to the specificed distance. More...
 
std::vector< monster * > get_fishable_monsters (std::unordered_set< tripoint > &fishable_locations)
 Get the fishable monsters within the provided fishable locations. More...
 
void fling_creature (Creature *c, const units::angle &dir, float flvel, bool controlled=false, bool suppress_map_update=false)
 Flings the input creature in the given direction. More...
 
float natural_light_level (int zlev) const
 
unsigned char light_level (int zlev) const
 Returns coarse number-of-squares of visibility at the current light level. More...
 
void reset_light_level ()
 
character_id assign_npc_id ()
 
Creatureis_hostile_nearby ()
 
Creatureis_hostile_very_close ()
 
point update_map (player &p)
 
point update_map (int &x, int &y)
 
void update_overmap_seen ()
 
void process_artifact (item &it, player &p)
 
void add_artifact_messages (const std::vector< art_effect_passive > &effects)
 
void add_artifact_dreams ()
 
void peek ()
 
void peek (const tripoint &p)
 
cata::optional< tripointlook_debug ()
 
bool check_zone (const zone_type_id &type, const tripoint &where) const
 
bool check_near_zone (const zone_type_id &type, const tripoint &where) const
 Checks whether or not there is a zone of particular type nearby. More...
 
bool is_zones_manager_open () const
 
void zones_manager ()
 
cata::optional< tripointlook_around ()
 
look_around_result look_around (bool show_window, tripoint &center, const tripoint &start_point, bool has_first_point, bool select_zone, bool peeking, bool is_moving_zone=false, const tripoint &end_point=tripoint_zero)
 
void pre_print_all_tile_info (const tripoint &lp, const catacurses::window &w_info, int &line, int last_line, const visibility_variables &cache)
 
void print_all_tile_info (const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line, int last_line, const visibility_variables &cache)
 
void draw_look_around_cursor (const tripoint &lp, const visibility_variables &cache)
 
void extended_description (const tripoint &p)
 Long description of (visible) things at tile. More...
 
void draw_trail_to_square (const tripoint &t, bool bDrawX)
 
int inventory_item_menu (item_location locThisItem, const std::function< int()> &startx=[]() { return 0;}, const std::function< int()> &width=[]() { return 50;}, inventory_item_menu_positon position=RIGHT_OF_INFO)
 
item_location inv_map_splice (item_filter filter, const std::string &title, int radius=0, const std::string &none_message="")
 Custom-filtered menu for inventory and nearby items and those that within specified radius. More...
 
bool has_gametype () const
 
special_game_id gametype () const
 
void toggle_fullscreen ()
 
void toggle_pixel_minimap ()
 
void reload_tileset ()
 
void temp_exit_fullscreen ()
 
void reenter_fullscreen ()
 
void zoom_in ()
 
void zoom_out ()
 
void reset_zoom ()
 
void set_zoom (int level)
 
int get_zoom () const
 
int get_moves_since_last_save () const
 
int get_user_action_counter () const
 
bool take_screenshot (const std::string &file_path) const
 Saves a screenshot of the current viewport, as a PNG file, to the given location. More...
 
bool take_screenshot () const
 Saves a screenshot of the current viewport, as a PNG file. More...
 
int get_levx () const
 The top left corner of the reality bubble (in submaps coordinates). More...
 
int get_levy () const
 
int get_levz () const
 
void load_map (const tripoint &pos_sm)
 Load the main map at given location, see map::load, in global, absolute submap coordinates. More...
 
void load_map (const tripoint_abs_sm &pos_sm)
 
overmapget_cur_om () const
 The overmap which contains the center submap of the reality bubble. More...
 
std::vector< npc * > allies ()
 Get all living player allies. More...
 
void set_driving_view_offset (const point &p)
 
void calc_driving_offset (vehicle *veh=nullptr)
 
void open_gate (const tripoint &p)
 
void knockback (const tripoint &s, const tripoint &t, int force, int stun, int dam_mult)
 
void knockback (std::vector< tripoint > &traj, int stun, int dam_mult)
 
void draw_bullet (const tripoint &t, int i, const std::vector< tripoint > &trajectory, char bullet)
 
void draw_hit_mon (const tripoint &p, const monster &m, bool dead=false)
 
void draw_hit_player (const Character &p, int dam)
 
void draw_line (const tripoint &p, const tripoint &center_point, const std::vector< tripoint > &points, bool noreveal=false)
 
void draw_line (const tripoint &p, const std::vector< tripoint > &points)
 
void draw_weather (const weather_printable &wPrint)
 
void draw_sct ()
 
void draw_zones (const tripoint &start, const tripoint &end, const tripoint &offset)
 
void draw_critter (const Creature &critter, const tripoint &center)
 
void draw_critter_highlighted (const Creature &critter, const tripoint &center)
 
void draw_cursor (const tripoint &p)
 
void draw_highlight (const tripoint &p)
 
void draw_radiation_override (const tripoint &p, int rad)
 
void draw_terrain_override (const tripoint &p, const ter_id &id)
 
void draw_furniture_override (const tripoint &p, const furn_id &id)
 
void draw_graffiti_override (const tripoint &p, bool has)
 
void draw_trap_override (const tripoint &p, const trap_id &id)
 
void draw_field_override (const tripoint &p, const field_type_id &id)
 
void draw_item_override (const tripoint &p, const itype_id &id, const mtype_id &mid, bool hilite)
 
void draw_vpart_override (const tripoint &p, const vpart_id &id, int part_mod, units::angle veh_dir, bool hilite, const point &mount)
 
void draw_below_override (const tripoint &p, bool draw)
 
void draw_monster_override (const tripoint &p, const mtype_id &id, int count, bool more, Creature::Attitude att)
 
bool is_in_viewport (const tripoint &p, int margin=0) const
 
bool check_safe_mode_allowed (bool repeat_safe_mode_warnings=true)
 Check whether movement is allowed according to safe mode settings. More...
 
void set_safe_mode (safe_mode_type mode)
 
void exam_vehicle (vehicle &veh, const point &cp=point_zero)
 open vehicle interaction screen More...
 
bool forced_door_closing (const tripoint &p, const ter_id &door_type, int bash_dmg)
 
bool load (const std::string &world)
 Attempt to load first valid save (if any) in world. More...
 
bool npc_menu (npc &who)
 Returns true if the menu handled stuff and player shouldn't do anything else. More...
 
bool phasing_move (const tripoint &dest, bool via_ramp=false)
 
bool walk_move (const tripoint &dest, bool via_ramp=false)
 
void on_move_effects ()
 
void reload (item_location &loc, bool prompt=false, bool empty=true)
 
void reload_item ()
 
void reload_wielded (bool prompt=false)
 
void reload_weapon (bool try_everything=true)
 
point place_player (const tripoint &dest)
 
void place_player_overmap (const tripoint_abs_omt &om_dest)
 
bool unload (item_location loc)
 
unsigned int get_seed () const
 
void set_npcs_dirty ()
 If invoked, NPCs will be reloaded before next turn. More...
 
void set_critter_died ()
 If invoked, dead will be cleaned this turn. More...
 
void mon_info (const catacurses::window &, int hor_padding=0)
 
void mon_info_update ()
 
void cleanup_dead ()
 
bool is_dangerous_tile (const tripoint &dest_loc) const
 
std::vector< std::string > get_dangerous_tile (const tripoint &dest_loc) const
 
bool prompt_dangerous_tile (const tripoint &dest_loc) const
 
void despawn_monster (monster &critter)
 Despawn a specific monster, it's stored on the overmap. More...
 
void win ()
 Marks the game as won. More...
 
bool disable_robot (const tripoint &p)
 If there is a robot (that can be disabled), query the player and try to disable it. More...
 
void draw_pixel_minimap (const catacurses::window &w)
 
void quicksave ()
 
void disp_NPCs ()
 
void list_missions ()
 
event_busevents ()
 
stats_trackerstats ()
 
memorial_loggermemorial ()
 
spell_eventsspell_events_subscriber ()
 
void display_toggle_overlay (action_id)
 
bool display_overlay_state (action_id)
 
void toggle_debug_hour_timer ()
 
tripoint mouse_edge_scrolling_terrain (input_context &ctxt)
 Used to implement mouse "edge scrolling". More...
 
tripoint mouse_edge_scrolling_overmap (input_context &ctxt)
 This variant is suitable for the overmap. More...
 
void shift_destination_preview (const point &delta)
 
bool slip_down ()
 Checks if player is able to successfully climb to/from some terrain and not slip down. More...
 
monsterplace_critter_at (const mtype_id &id, const tripoint &p)
 Adds critters to the reality bubble, creating them if necessary. More...
 
monsterplace_critter_at (const shared_ptr_fast< monster > &mon, const tripoint &p)
 
monsterplace_critter_around (const mtype_id &id, const tripoint &center, int radius)
 
monsterplace_critter_around (const shared_ptr_fast< monster > &mon, const tripoint &center, int radius, bool forced=false)
 
monsterplace_critter_within (const mtype_id &id, const tripoint_range< tripoint > &range)
 
monsterplace_critter_within (const shared_ptr_fast< monster > &mon, const tripoint_range< tripoint > &range)
 

Public Attributes

mapm
 
avataru
 
scent_mapscent
 
timed_event_managertimed_events
 
pimpl< Creature_trackercritter_tracker
 
pimpl< faction_managerfaction_manager_ptr
 
pimpl< drop_token_providertoken_provider_ptr
 
quit_status uquit
 Used in main.cpp to determine what type of quit is being performed. More...
 
bool new_game = false
 True if the game has just started or loaded, else false. More...
 
const scenarioscen
 
std::vector< monstercoming_to_stairs
 
int monstairz = 0
 
tripoint ter_view_p
 
catacurses::window w_terrain
 
catacurses::window w_overmap
 
catacurses::window w_omlegend
 
catacurses::window w_minimap
 
catacurses::window w_pixel_minimap
 
point driving_view_offset
 
bool debug_pathfinding = false
 
bool debug_submap_grid_overlay = false
 
Creaturedisplaying_visibility_creature
 Creature for which to display the visibility map. More...
 
int displaying_lighting_condition = 0
 Type of lighting condition overlay to display. More...
 
bool show_panel_adm = false
 
bool right_sidebar = false
 
bool fullscreen = false
 
bool was_fullscreen = false
 
bool auto_travel_mode = false
 
bool queue_screenshot = false
 
safe_mode_type safe_mode
 
int turnssincelastmon = 0
 
int mostseen = 0
 

Protected Member Functions

void load_data_from_dir (const std::string &path, const std::string &src, loading_ui &ui)
 Loads dynamic data from the given directory. More...
 

Private Types

enum class  vmenu_ret : int { CHANGE_TAB , QUIT , FIRE }
 

Private Member Functions

void unload_npcs ()
 Unloads all NPCs. More...
 
bool load (const save_t &name)
 
void load_master ()
 
bool start_game ()
 
bool save_factions_missions_npcs ()
 
void reset_npc_dispositions ()
 
void serialize_master (std::ostream &fout)
 
bool save_artifacts ()
 
bool save_maps ()
 
void init_autosave ()
 
void create_starting_npcs ()
 
vehicleplace_vehicle_nearby (const vproto_id &id, const point_abs_omt &origin, int min_distance, int max_distance, const std::vector< std::string > &omt_search_types={})
 
void list_items_monsters ()
 
game::vmenu_ret list_items (const std::vector< map_item_stack > &item_list)
 
std::vector< map_item_stackfind_nearby_items (int iRadius)
 
void reset_item_list_state (const catacurses::window &window, int height, bool bRadiusSort)
 
game::vmenu_ret list_monsters (const std::vector< Creature * > &monster_list)
 
bool grabbed_move (const tripoint &dp)
 Check for dangerous stuff at dest_loc, return false if the player decides not to step there. More...
 
bool grabbed_veh_move (const tripoint &dp)
 
bool grabbed_furn_move (const tripoint &dp)
 
void control_vehicle ()
 
void examine (const tripoint &p)
 
void examine ()
 
void pickup ()
 
void pickup (const tripoint &p)
 
void pickup_feet ()
 
void drop ()
 
void drop_in_direction ()
 
void butcher ()
 
void wield ()
 
void wield (item_location &loc)
 
void chat ()
 
void print_fields_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line)
 
void print_terrain_info (const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line)
 
void print_trap_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line)
 
void print_creature_info (const Creature *creature, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_vehicle_info (const vehicle *veh, int veh_part, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_visibility_info (const catacurses::window &w_look, int column, int &line, visibility_type visibility)
 
void print_items_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_graffiti_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
 
input_context get_player_input (std::string &action)
 
void replace_stair_monsters ()
 
void update_stair_monsters ()
 
void shift_monsters (const tripoint &shift)
 Shift all active monsters, the shift vector is the number of shifted submaps. More...
 
void perhaps_add_random_npc ()
 
void monmove ()
 
void overmap_npc_move ()
 
void process_voluntary_act_interrupt ()
 
void process_activity ()
 
void handle_key_blocking_activity ()
 
void open_consume_item_menu ()
 
bool handle_action ()
 
bool try_get_right_click_action (action_id &act, const tripoint &mouse_target)
 
bool try_get_left_click_action (action_id &act, const tripoint &mouse_target)
 
void item_action_menu ()
 
bool is_game_over ()
 
void death_screen ()
 
void win_screen ()
 
void draw_minimap ()
 
void autosave ()
 
void quickload ()
 
bool handle_mouseview (input_context &ctxt, std::string &action)
 
void display_faction_epilogues ()
 
void disp_NPC_epilogues ()
 
void display_scent ()
 
void display_temperature ()
 
void display_vehicle_ai ()
 
void display_visibility ()
 
void display_lighting ()
 
void display_radiation ()
 
void display_transparency ()
 
Creatureis_hostile_within (int distance)
 
void move_save_to_graveyard (const std::string &dirname)
 
bool save_player_data ()
 
std::pair< tripoint, tripointmouse_edge_scrolling (input_context &ctxt, int speed, const tripoint &last, bool iso)
 

Private Attributes

bool is_looking = false
 
std::vector< weak_ptr_fast< draw_callback_t > > draw_callbacks
 
cata::optional< action_iddisplaying_overlays
 
class game::debug_hour_timer debug_hour_timer
 
pimpl< mapmap_ptr
 
pimpl< avataru_ptr
 
pimpl< live_viewliveview_ptr
 
live_viewliveview
 
pimpl< scent_mapscent_ptr
 
pimpl< timed_event_managertimed_event_manager_ptr
 
pimpl< event_busevent_bus_ptr
 
pimpl< stats_trackerstats_tracker_ptr
 
pimpl< achievements_trackerachievements_tracker_ptr
 
pimpl< kill_trackerkill_tracker_ptr
 
pimpl< memorial_loggermemorial_logger_ptr
 
pimpl< spell_eventsspell_events_ptr
 
pimpl< distribution_grid_trackergrid_tracker_ptr
 
pimpl< weather_managerweather_manager_ptr
 
shared_ptr_fast< playeru_shared_ptr
 
catacurses::window w_terrain_ptr
 
catacurses::window w_minimap_ptr
 
std::string sFilter
 
std::string list_item_upvote
 
std::string list_item_downvote
 
bool safe_mode_warning_logged = false
 
bool bVMonsterLookFire = false
 
character_id next_npc_id
 
std::list< shared_ptr_fast< npc > > active_npc
 
int next_mission_id = 0
 
std::set< character_idfollower_ids
 
int moves_since_last_save = 0
 
time_t last_save_timestamp
 
std::array< float, OVERMAP_LAYERSlatest_lightlevels
 
time_point remoteveh_cache_time
 
vehicleremoteveh_cache
 
bool npcs_dirty = false
 Has a NPC been spawned since last load? More...
 
bool critter_died = false
 Has anything died in this turn and needs to be cleaned up? More...
 
bool first_redraw_since_waiting_started = true
 Is this the first redraw since waiting (sleeping or activity) started. More...
 
bool zones_manager_open = false
 Is Zone manager open or not - changes graphics of some zone tiles. More...
 
std::unique_ptr< special_gamegamemode
 
int user_action_counter = 0
 
int tileset_zoom = 0
 How far the tileset should be zoomed out, 16 is default. More...
 
unsigned int seed = 0
 Seed for all the random numbers that should have consistent randomness (weather). More...
 
std::vector< tripointdestination_preview
 
std::chrono::time_point< std::chrono::steady_clock > last_mouse_edge_scroll
 
tripoint last_mouse_edge_scroll_vector_terrain
 
tripoint last_mouse_edge_scroll_vector_overmap
 
weak_ptr_fast< ui_adaptormain_ui_adaptor
 
std::unique_ptr< static_popupwait_popup
 

Friends

class editmap
 
class advanced_inventory
 
class main_menu
 
class monster_range
 
class Creature_range
 
distribution_grid_trackerget_distribution_grid_tracker ()
 Returns distribution grid tracker that is a part of the global game *g. More...
 
mapget_map ()
 
Characterget_player_character ()
 
avatarget_avatar ()
 
weather_managerget_weather ()
 

Detailed Description

Definition at line 143 of file game.h.

Member Enumeration Documentation

◆ inventory_item_menu_positon

Enumerator
RIGHT_TERMINAL_EDGE 
LEFT_OF_INFO 
RIGHT_OF_INFO 
LEFT_TERMINAL_EDGE 

Definition at line 611 of file game.h.

611 {
616 };
@ LEFT_OF_INFO
Definition: game.h:613
@ RIGHT_OF_INFO
Definition: game.h:614
@ RIGHT_TERMINAL_EDGE
Definition: game.h:612
@ LEFT_TERMINAL_EDGE
Definition: game.h:615

◆ vmenu_ret

enum class game::vmenu_ret : int
strongprivate
Enumerator
CHANGE_TAB 
QUIT 
FIRE 

Definition at line 805 of file game.h.

805 : int {
806 CHANGE_TAB,
807 QUIT,
808 FIRE, // Who knew, apparently you can do that in list_monsters
809 };

Constructor & Destructor Documentation

◆ game()

game::game ( )

Definition at line 284 of file game.cpp.

284 :
286 scent_ptr( *this ),
289 m( *map_ptr ),
290 u( *u_ptr ),
291 scent( *scent_ptr ),
293 uquit( QUIT_NO ),
294 new_game( false ),
296 mostseen( 0 ),
299 next_npc_id( 1 ),
300 next_mission_id( 1 ),
304 seed( 0 ),
305 last_mouse_edge_scroll( std::chrono::steady_clock::now() )
306{
314 world_generator = std::make_unique<worldfactory>();
315 // do nothing, everything that was in here is moved to init_data() which is called immediately after g = new game; in main.cpp
316 // The reason for this move is so that g is not uninitialized when it gets to installing the parts into vehicles.
317}
void subscribe(event_subscriber *)
Definition: event_bus.cpp:39
int mostseen
Definition: game.h:1071
pimpl< spell_events > spell_events_ptr
Definition: game.h:1006
safe_mode_type safe_mode
Definition: game.h:1068
bool safe_mode_warning_logged
Definition: game.h:1082
pimpl< timed_event_manager > timed_event_manager_ptr
Definition: game.h:1000
std::chrono::time_point< std::chrono::steady_clock > last_mouse_edge_scroll
Definition: game.h:1116
quit_status uquit
Used in main.cpp to determine what type of quit is being performed.
Definition: game.h:1026
event_bus & events()
Definition: game.cpp:3078
pimpl< stats_tracker > stats_tracker_ptr
Definition: game.h:1002
character_id next_npc_id
Definition: game.h:1084
pimpl< kill_tracker > kill_tracker_ptr
Definition: game.h:1004
void reset_light_level()
Definition: game.cpp:3922
pimpl< memorial_logger > memorial_logger_ptr
Definition: game.h:1005
shared_ptr_fast< player > u_shared_ptr
Definition: game.h:1073
pimpl< map > map_ptr
Definition: game.h:995
bool first_redraw_since_waiting_started
Is this the first redraw since waiting (sleeping or activity) started.
Definition: game.h:1099
pimpl< live_view > liveview_ptr
Definition: game.h:997
pimpl< achievements_tracker > achievements_tracker_ptr
Definition: game.h:1003
pimpl< scent_map > scent_ptr
Definition: game.h:999
timed_event_manager & timed_events
Definition: game.h:1014
unsigned int seed
Seed for all the random numbers that should have consistent randomness (weather).
Definition: game.h:1111
int next_mission_id
Definition: game.h:1086
bool new_game
True if the game has just started or loaded, else false.
Definition: game.h:1028
pimpl< distribution_grid_tracker > grid_tracker_ptr
Definition: game.h:1007
map & m
Definition: game.h:1011
avatar & u
Definition: game.h:1012
scent_map & scent
Definition: game.h:1013
int user_action_counter
Definition: game.h:1105
live_view & liveview
Definition: game.h:998
int tileset_zoom
How far the tileset should be zoomed out, 16 is default.
Definition: game.h:1108
pimpl< avatar > u_ptr
Definition: game.h:996
time_point remoteveh_cache_time
Definition: game.h:1092
static void achievement_attained(const achievement *a)
Definition: game.cpp:277
static constexpr int DEFAULT_TILESET_ZOOM
Definition: game.h:41
@ SAFE_MODE_ON
Definition: game.h:78
@ QUIT_NO
Definition: game.h:68
mapbuffer MAPBUFFER
Definition: mapbuffer.cpp:40
const time_point before_time_starts
A time point that is always before the current turn, even when the game has just started.
Definition: calendar.cpp:25
For use with smart pointers when you don't actually want the deleter to do anything.
Definition: cata_utility.h:28
std::unique_ptr< worldfactory > world_generator

References achievements_tracker_ptr, events(), first_redraw_since_waiting_started, kill_tracker_ptr, memorial_logger_ptr, reset_light_level(), spell_events_ptr, stats_tracker_ptr, event_bus::subscribe(), and world_generator.

◆ ~game()

game::~game ( )
default

Member Function Documentation

◆ add_artifact_dreams()

void game::add_artifact_dreams ( )

Definition at line 12345 of file game.cpp.

12346{
12347 //If player is sleeping, get a dream from a carried artifact
12348 //Don't need to check that player is sleeping here, that's done before calling
12349 std::list<item *> art_items = g->u.get_artifact_items();
12350 std::vector<item *> valid_arts;
12351 std::vector<std::vector<std::string>>
12352 valid_dreams; // Tracking separately so we only need to check its req once
12353 //Pull the list of dreams
12354 add_msg( m_debug, "Checking %s carried artifacts", art_items.size() );
12355 for( auto &it : art_items ) {
12356 //Pick only the ones with an applicable dream
12357 const cata::value_ptr<islot_artifact> &art = it->type->artifact;
12358 if( art && art->charge_req != ACR_NULL &&
12359 ( it->ammo_remaining() < it->ammo_capacity() ||
12360 it->ammo_capacity() == 0 ) ) { //or max 0 in case of wacky mod shenanigans
12361 add_msg( m_debug, "Checking artifact %s", it->tname() );
12362 if( check_art_charge_req( *it ) ) {
12363 add_msg( m_debug, " Has freq %s,%s", art->dream_freq_met, art->dream_freq_unmet );
12364 if( art->dream_freq_met > 0 && x_in_y( art->dream_freq_met, 100 ) ) {
12365 add_msg( m_debug, "Adding met dream from %s", it->tname() );
12366 valid_arts.push_back( it );
12367 valid_dreams.push_back( art->dream_msg_met );
12368 }
12369 } else {
12370 add_msg( m_debug, " Has freq %s,%s", art->dream_freq_met, art->dream_freq_unmet );
12371 if( art->dream_freq_unmet > 0 && x_in_y( art->dream_freq_unmet, 100 ) ) {
12372 add_msg( m_debug, "Adding unmet dream from %s", it->tname() );
12373 valid_arts.push_back( it );
12374 valid_dreams.push_back( art->dream_msg_unmet );
12375 }
12376 }
12377 }
12378 }
12379 if( !valid_dreams.empty() ) {
12380 add_msg( m_debug, "Found %s valid artifact dreams", valid_dreams.size() );
12381 const int selected = rng( 0, valid_arts.size() - 1 );
12382 auto it = valid_arts[selected];
12383 auto msg = random_entry( valid_dreams[selected] );
12384 const std::string &dream = string_format( _( msg ), it->tname() );
12385 add_msg( dream );
12386 } else {
12387 add_msg( m_debug, "Didn't have any dreams, sorry" );
12388 }
12389}
units::quantity< V, B > rng(const units::quantity< V, B > &min, const units::quantity< V, B > &max)
Definition: artifact.cpp:32
@ ACR_NULL
Definition: artifact.h:79
bool x_in_y(const time_duration &a, const time_duration &b)
Definition: calendar.cpp:521
This class is essentially a copyable unique pointer.
Definition: value_ptr.h:19
@ m_debug
Definition: enums.h:264
std::unique_ptr< game > g
Definition: game.cpp:267
bool check_art_charge_req(item &it)
Definition: game.cpp:12048
void add_msg(std::string msg)
Definition: messages.cpp:884
V random_entry(const C &container, D default_value)
Returns a random entry in the container.
Definition: rng.h:88
std::string string_format(std::string format, Args &&...args)
Simple wrapper over string_formatter::parse.
Definition: mutation.h:39
#define _(msg)
Definition: translations.h:116

References _, ACR_NULL, add_msg(), check_art_charge_req(), g, m_debug, random_entry(), rng(), string_format(), and x_in_y().

Referenced by do_turn().

◆ add_artifact_messages()

void game::add_artifact_messages ( const std::vector< art_effect_passive > &  effects)

Definition at line 12167 of file game.cpp.

12168{
12169 int net_str = 0;
12170 int net_dex = 0;
12171 int net_per = 0;
12172 int net_int = 0;
12173 int net_speed = 0;
12174
12175 for( auto &i : effects ) {
12176 switch( i ) {
12177 case AEP_STR_UP:
12178 net_str += 4;
12179 break;
12180 case AEP_DEX_UP:
12181 net_dex += 4;
12182 break;
12183 case AEP_PER_UP:
12184 net_per += 4;
12185 break;
12186 case AEP_INT_UP:
12187 net_int += 4;
12188 break;
12189 case AEP_ALL_UP:
12190 net_str += 2;
12191 net_dex += 2;
12192 net_per += 2;
12193 net_int += 2;
12194 break;
12195 case AEP_STR_DOWN:
12196 net_str -= 3;
12197 break;
12198 case AEP_DEX_DOWN:
12199 net_dex -= 3;
12200 break;
12201 case AEP_PER_DOWN:
12202 net_per -= 3;
12203 break;
12204 case AEP_INT_DOWN:
12205 net_int -= 3;
12206 break;
12207 case AEP_ALL_DOWN:
12208 net_str -= 2;
12209 net_dex -= 2;
12210 net_per -= 2;
12211 net_int -= 2;
12212 break;
12213
12214 case AEP_SPEED_UP:
12215 net_speed += 20;
12216 break;
12217 case AEP_SPEED_DOWN:
12218 net_speed -= 20;
12219 break;
12220
12221 case AEP_PBLUE:
12222 break; // No message
12223
12224 case AEP_SNAKES:
12225 add_msg( m_warning, _( "Your skin feels slithery." ) );
12226 break;
12227
12228 case AEP_INVISIBLE:
12229 add_msg( m_good, _( "You fade into invisibility!" ) );
12230 break;
12231
12232 case AEP_CLAIRVOYANCE:
12234 add_msg( m_good, _( "You can see through walls!" ) );
12235 break;
12236
12238 add_msg( m_good, _( "You can see through everything!" ) );
12239 break;
12240
12241 case AEP_STEALTH:
12242 add_msg( m_good, _( "Your steps stop making noise." ) );
12243 break;
12244
12245 case AEP_GLOW:
12246 add_msg( _( "A glow of light forms around you." ) );
12247 break;
12248
12249 case AEP_PSYSHIELD:
12250 add_msg( m_good, _( "Your mental state feels protected." ) );
12251 break;
12252
12254 add_msg( m_good, _( "You feel insulated." ) );
12255 break;
12256
12257 case AEP_CARRY_MORE:
12258 add_msg( m_good, _( "Your back feels strengthened." ) );
12259 break;
12260
12261 case AEP_FUN:
12262 add_msg( m_good, _( "You feel a pleasant tingle." ) );
12263 break;
12264
12265 case AEP_HUNGER:
12266 add_msg( m_warning, _( "You feel hungry." ) );
12267 break;
12268
12269 case AEP_THIRST:
12270 add_msg( m_warning, _( "You feel thirsty." ) );
12271 break;
12272
12273 case AEP_EVIL:
12274 add_msg( m_warning, _( "You feel an evil presence…" ) );
12275 break;
12276
12277 case AEP_SCHIZO:
12278 add_msg( m_bad, _( "You feel a tickle of insanity." ) );
12279 break;
12280
12281 case AEP_RADIOACTIVE:
12282 add_msg( m_warning, _( "Your skin prickles with radiation." ) );
12283 break;
12284
12285 case AEP_MUTAGENIC:
12286 add_msg( m_bad, _( "You feel your genetic makeup degrading." ) );
12287 break;
12288
12289 case AEP_ATTENTION:
12290 add_msg( m_warning, _( "You feel an otherworldly attention upon you…" ) );
12291 break;
12292
12293 case AEP_FORCE_TELEPORT:
12294 add_msg( m_bad, _( "You feel a force pulling you inwards." ) );
12295 break;
12296
12297 case AEP_MOVEMENT_NOISE:
12298 add_msg( m_warning, _( "You hear a rattling noise coming from inside yourself." ) );
12299 break;
12300
12301 case AEP_BAD_WEATHER:
12302 add_msg( m_warning, _( "You feel storms coming." ) );
12303 break;
12304
12305 case AEP_SICK:
12306 add_msg( m_bad, _( "You feel unwell." ) );
12307 break;
12308
12309 case AEP_SMOKE:
12310 add_msg( m_warning, _( "A cloud of smoke appears." ) );
12311 break;
12312 default:
12313 //Suppress warnings
12314 break;
12315 }
12316 }
12317
12318 std::string stat_info;
12319 if( net_str != 0 ) {
12320 stat_info += string_format( _( "Str %s%d! " ),
12321 ( net_str > 0 ? "+" : "" ), net_str );
12322 }
12323 if( net_dex != 0 ) {
12324 stat_info += string_format( _( "Dex %s%d! " ),
12325 ( net_dex > 0 ? "+" : "" ), net_dex );
12326 }
12327 if( net_int != 0 ) {
12328 stat_info += string_format( _( "Int %s%d! " ),
12329 ( net_int > 0 ? "+" : "" ), net_int );
12330 }
12331 if( net_per != 0 ) {
12332 stat_info += string_format( _( "Per %s%d! " ),
12333 ( net_per > 0 ? "+" : "" ), net_per );
12334 }
12335
12336 if( !stat_info.empty() ) {
12337 add_msg( m_neutral, stat_info );
12338 }
12339
12340 if( net_speed != 0 ) {
12341 add_msg( m_info, _( "Speed %s%d!" ), ( net_speed > 0 ? "+" : "" ), net_speed );
12342 }
12343}
@ m_good
Definition: enums.h:253
@ m_neutral
Definition: enums.h:260
@ m_info
Definition: enums.h:258
@ m_bad
Definition: enums.h:254
@ m_warning
Definition: enums.h:257
@ AEP_GLOW
Definition: enums.h:115
@ AEP_MUTAGENIC
Definition: enums.h:130
@ AEP_ALL_UP
Definition: enums.h:106
@ AEP_INT_UP
Definition: enums.h:105
@ AEP_INT_DOWN
Definition: enums.h:135
@ AEP_PER_UP
Definition: enums.h:104
@ AEP_PSYSHIELD
Definition: enums.h:116
@ AEP_CLAIRVOYANCE_PLUS
Definition: enums.h:142
@ AEP_MOVEMENT_NOISE
Definition: enums.h:139
@ AEP_STEALTH
Definition: enums.h:113
@ AEP_CARRY_MORE
Definition: enums.h:118
@ AEP_THIRST
Definition: enums.h:125
@ AEP_SPEED_UP
Definition: enums.h:107
@ AEP_EVIL
Definition: enums.h:127
@ AEP_ALL_DOWN
Definition: enums.h:136
@ AEP_DEX_UP
Definition: enums.h:103
@ AEP_SCHIZO
Definition: enums.h:128
@ AEP_DEX_DOWN
Definition: enums.h:133
@ AEP_FUN
Definition: enums.h:120
@ AEP_PER_DOWN
Definition: enums.h:134
@ AEP_FORCE_TELEPORT
Definition: enums.h:138
@ AEP_ATTENTION
Definition: enums.h:131
@ AEP_RADIOACTIVE
Definition: enums.h:129
@ AEP_SUPER_CLAIRVOYANCE
Definition: enums.h:112
@ AEP_BAD_WEATHER
Definition: enums.h:140
@ AEP_SICK
Definition: enums.h:141
@ AEP_CLAIRVOYANCE
Definition: enums.h:111
@ AEP_INVISIBLE
Definition: enums.h:110
@ AEP_STR_UP
Definition: enums.h:102
@ AEP_STR_DOWN
Definition: enums.h:132
@ AEP_HUNGER
Definition: enums.h:124
@ AEP_RESIST_ELECTRICITY
Definition: enums.h:117
@ AEP_PBLUE
Definition: enums.h:108
@ AEP_SPEED_DOWN
Definition: enums.h:137
@ AEP_SNAKES
Definition: enums.h:109
@ AEP_SMOKE
Definition: enums.h:126

References _, add_msg(), AEP_ALL_DOWN, AEP_ALL_UP, AEP_ATTENTION, AEP_BAD_WEATHER, AEP_CARRY_MORE, AEP_CLAIRVOYANCE, AEP_CLAIRVOYANCE_PLUS, AEP_DEX_DOWN, AEP_DEX_UP, AEP_EVIL, AEP_FORCE_TELEPORT, AEP_FUN, AEP_GLOW, AEP_HUNGER, AEP_INT_DOWN, AEP_INT_UP, AEP_INVISIBLE, AEP_MOVEMENT_NOISE, AEP_MUTAGENIC, AEP_PBLUE, AEP_PER_DOWN, AEP_PER_UP, AEP_PSYSHIELD, AEP_RADIOACTIVE, AEP_RESIST_ELECTRICITY, AEP_SCHIZO, AEP_SICK, AEP_SMOKE, AEP_SNAKES, AEP_SPEED_DOWN, AEP_SPEED_UP, AEP_STEALTH, AEP_STR_DOWN, AEP_STR_UP, AEP_SUPER_CLAIRVOYANCE, AEP_THIRST, m_bad, m_good, m_info, m_neutral, m_warning, and string_format().

◆ add_draw_callback()

void game::add_draw_callback ( shared_ptr_fast< draw_callback_t cb)

Definition at line 3373 of file game.cpp.

3374{
3375 draw_callbacks.erase(
3376 std::remove_if( draw_callbacks.begin(), draw_callbacks.end(),
3377 []( const weak_ptr_fast<draw_callback_t> &cbw ) {
3378 return cbw.expired();
3379 } ),
3380 draw_callbacks.end()
3381 );
3382 draw_callbacks.emplace_back( cb );
3383 cb->added = true;
3385}
void invalidate_main_ui_adaptor() const
Definition: game.cpp:3338
std::vector< weak_ptr_fast< draw_callback_t > > draw_callbacks
Definition: game.h:251
std::weak_ptr< T > weak_ptr_fast
Definition: memory_fast.h:17

References draw_callbacks, and invalidate_main_ui_adaptor().

Referenced by get_player_input(), list_items(), list_monsters(), look_around(), pickup(), and zones_manager().

◆ add_npc_follower()

void game::add_npc_follower ( const character_id id)

Add follower id to set of followers.

Definition at line 1958 of file game.cpp.

1959{
1960 follower_ids.insert( id );
1961 u.follower_ids.insert( id );
1962}
std::set< character_id > follower_ids
Definition: game.h:1087
std::set< character_id > follower_ids
Definition: player.h:710

References follower_ids, player::follower_ids, and u.

Referenced by validate_npc_followers().

◆ all_creatures()

game::Creature_range game::all_creatures ( )

Returns an anonymous range that contains all creatures.

The range allows iteration via a range-based for loop, e.g. for( Creature &critter : all_creatures() ) { ... }. One shall not store the returned range nor the iterators. One can freely remove and add creatures to the game during the iteration. Added creatures will not be iterated over.

Definition at line 12501 of file game.cpp.

12502{
12503 return Creature_range( *this );
12504}
friend class Creature_range
Definition: game.h:360

References Creature_range.

Referenced by draw_ter(), get_creature_if(), and get_creatures_if().

◆ all_monsters()

game::monster_range game::all_monsters ( )

Same as all_creatures but iterators only over monsters.

Definition at line 12506 of file game.cpp.

12507{
12508 return monster_range( *this );
12509}
friend class monster_range
Definition: game.h:359

References monster_range.

Referenced by cleanup_at_end(), disp_NPCs(), get_fishable_monsters(), monmove(), place_player_overmap(), shift_monsters(), start_game(), validate_mounted_npcs(), and vertical_move().

◆ all_npcs()

game::npc_range game::all_npcs ( )

Same as all_creatures but iterators only over npcs.

Definition at line 12511 of file game.cpp.

12512{
12513 return npc_range( *this );
12514}

Referenced by do_turn(), and get_npcs_if().

◆ allies()

std::vector< npc * > game::allies ( )

Get all living player allies.

Definition at line 12415 of file game.cpp.

12416{
12417 return get_npcs_if( [&]( const npc & guy ) {
12418 if( !guy.is_hallucination() ) {
12419 return guy.is_ally( g->u );
12420 } else {
12421 return false;
12422 }
12423 } );
12424}
std::vector< npc * > get_npcs_if(const std::function< bool(const npc &)> &pred)
Definition: game.cpp:12438
Definition: npc.h:781
bool is_hallucination() const override
Definition: npc.cpp:3257

References get_npcs_if(), and npc::is_hallucination().

◆ assign_mission_id()

int game::assign_mission_id ( )

Returns the next available mission id.

Definition at line 1946 of file game.cpp.

1947{
1948 int ret = next_mission_id;
1950 return ret;
1951}

References next_mission_id, and cata::hash64_detail::ret.

◆ assign_npc_id()

character_id game::assign_npc_id ( )

Definition at line 3930 of file game.cpp.

3931{
3933 ++next_npc_id;
3934 return ret;
3935}

References next_npc_id, and cata::hash64_detail::ret.

Referenced by load(), and start_game().

◆ autopilot_vehicles()

void game::autopilot_vehicles ( )

process vehicles that are following the player

Definition at line 1751 of file game.cpp.

1752{
1753 for( wrapped_vehicle &veh : m.get_vehicles() ) {
1754 vehicle *&v = veh.v;
1755 if( v->is_following ) {
1756 v->drive_to_local_target( m.getabs( u.pos() ), true );
1757 } else if( v->is_patrolling ) {
1758 v->autopilot_patrol();
1759 }
1760 }
1761}
const tripoint & pos() const override
Definition: character.cpp:707
tripoint getabs(const tripoint &p) const
Translates local (to this map) coordinates of a square to global absolute coordinates.
Definition: map.cpp:8079
VehicleList get_vehicles()
Definition: map.cpp:232
A vehicle as a whole with all its components.
Definition: vehicle.h:675
void autopilot_patrol()
Definition: vehicle.cpp:701
bool is_following
Definition: vehicle.h:1964
bool is_patrolling
Definition: vehicle.h:1965
void drive_to_local_target(const tripoint &target, bool follow_protocol)
Definition: vehicle.cpp:816

References vehicle::autopilot_patrol(), vehicle::drive_to_local_target(), map::get_vehicles(), map::getabs(), vehicle::is_following, vehicle::is_patrolling, m, Character::pos(), and u.

Referenced by do_turn().

◆ autosave()

void game::autosave ( )
private

Definition at line 11834 of file game.cpp.

11835{
11836 //Don't autosave if the min-autosave interval has not passed since the last autosave/quicksave.
11837 if( time( nullptr ) < last_save_timestamp + 60 * get_option<int>( "AUTOSAVE_MINUTES" ) ) {
11838 return;
11839 }
11840 quicksave(); //Driving checks are handled by quicksave()
11841}
time_t last_save_timestamp
Definition: game.h:1089
void quicksave()
Definition: game.cpp:11789

References last_save_timestamp, and quicksave().

Referenced by do_turn().

◆ butcher()

void game::butcher ( )
private

Definition at line 8558 of file game.cpp.

8559{
8560 static const std::string salvage_string = "salvage";
8561 if( u.controlling_vehicle ) {
8562 add_msg( m_info, _( "You can't butcher while driving!" ) );
8563 return;
8564 }
8565
8566 const int factor = u.max_quality( quality_id( "BUTCHER" ) );
8567 const int factorD = u.max_quality( quality_id( "CUT_FINE" ) );
8568 const std::string no_knife_msg = _( "You don't have a butchering tool." );
8569 const std::string no_corpse_msg = _( "There are no corpses here to butcher." );
8570
8571 //You can't butcher on sealed terrain- you have to smash/shovel/etc it open first
8572 if( m.has_flag( "SEALED", u.pos() ) ) {
8573 if( m.sees_some_items( u.pos(), u ) ) {
8574 add_msg( m_info, _( "You can't access the items here." ) );
8575 } else if( factor > INT_MIN || factorD > INT_MIN ) {
8576 add_msg( m_info, no_corpse_msg );
8577 } else {
8578 add_msg( m_info, no_knife_msg );
8579 }
8580 return;
8581 }
8582
8583 const item *first_item_without_tools = nullptr;
8584 // Indices of relevant items
8585 std::vector<map_stack::iterator> corpses;
8586 std::vector<map_stack::iterator> disassembles;
8587 std::vector<map_stack::iterator> salvageables;
8588 map_stack items = m.i_at( u.pos() );
8589 const inventory &crafting_inv = u.crafting_inventory();
8590
8591 // TODO: Properly handle different material whitelists
8592 // TODO: Improve quality of this section
8593 auto salvage_filter = []( item it ) {
8594 const auto usable = it.get_usable_item( salvage_string );
8595 return usable != nullptr;
8596 };
8597
8598 std::vector< item * > salvage_tools = u.items_with( salvage_filter );
8599 int salvage_tool_index = INT_MIN;
8600 item *salvage_tool = nullptr;
8601 const salvage_actor *salvage_iuse = nullptr;
8602 if( !salvage_tools.empty() ) {
8603 salvage_tool = salvage_tools.front();
8604 salvage_tool_index = u.get_item_position( salvage_tool );
8605 item *usable = salvage_tool->get_usable_item( salvage_string );
8606 salvage_iuse = dynamic_cast<const salvage_actor *>(
8607 usable->get_use( salvage_string )->get_actor_ptr() );
8608 }
8609
8610 // Reserve capacity for each to hold entire item set if necessary to prevent
8611 // reallocations later on
8612 corpses.reserve( items.size() );
8613 salvageables.reserve( items.size() );
8614 disassembles.reserve( items.size() );
8615
8616 // Split into corpses, disassemble-able, and salvageable items
8617 // It's not much additional work to just generate a corpse list and
8618 // clear it later, but does make the splitting process nicer.
8619 for( map_stack::iterator it = items.begin(); it != items.end(); ++it ) {
8620 if( it->is_corpse() ) {
8621 corpses.push_back( it );
8622 } else {
8623 if( ( salvage_tool_index != INT_MIN ) && salvage_iuse->valid_to_cut_up( *it ) ) {
8624 salvageables.push_back( it );
8625 }
8626 if( u.can_disassemble( *it, crafting_inv ).success() ) {
8627 disassembles.push_back( it );
8628 } else if( !first_item_without_tools ) {
8629 first_item_without_tools = &*it;
8630 }
8631 }
8632 }
8633
8634 // Clear corpses if butcher and dissect factors are INT_MIN
8635 if( factor == INT_MIN && factorD == INT_MIN ) {
8636 corpses.clear();
8637 }
8638
8639 if( corpses.empty() && disassembles.empty() && salvageables.empty() ) {
8640 if( factor > INT_MIN || factorD > INT_MIN ) {
8641 add_msg( m_info, no_corpse_msg );
8642 } else {
8643 add_msg( m_info, no_knife_msg );
8644 }
8645
8646 if( first_item_without_tools ) {
8647 add_msg( m_info, _( "You don't have the necessary tools to disassemble any items here." ) );
8648 // Just for the "You need x to disassemble y" messages
8649 const auto ret = u.can_disassemble( *first_item_without_tools, crafting_inv );
8650 if( !ret.success() ) {
8651 add_msg( m_info, "%s", ret.c_str() );
8652 }
8653 }
8654 return;
8655 }
8656
8657 Creature *hostile_critter = is_hostile_very_close();
8658 if( hostile_critter != nullptr ) {
8659 if( !query_yn( _( "You see %s nearby! Start butchering anyway?" ),
8660 hostile_critter->disp_name() ) ) {
8661 return;
8662 }
8663 }
8664
8665 // Magic indices for special butcher options
8666 enum : int {
8667 MULTISALVAGE = MAX_ITEM_IN_SQUARE + 1,
8668 MULTIBUTCHER,
8669 MULTIDISASSEMBLE_ONE,
8670 MULTIDISASSEMBLE_ALL,
8671 NUM_BUTCHER_ACTIONS
8672 };
8673 // What are we butchering (i.e.. which vector to pick indices from)
8674 enum {
8675 BUTCHER_CORPSE,
8676 BUTCHER_DISASSEMBLE,
8677 BUTCHER_SALVAGE,
8678 BUTCHER_OTHER // For multisalvage etc.
8679 } butcher_select = BUTCHER_CORPSE;
8680 // Index to std::vector of iterators...
8681 int indexer_index = 0;
8682
8683 // Generate the indexed stacks so we can display them nicely
8684 const auto disassembly_stacks = generate_butcher_stack_display( disassembles );
8685 const auto salvage_stacks = generate_butcher_stack_display( salvageables );
8686 // Always ask before cutting up/disassembly, but not before butchery
8687 size_t ret = 0;
8688 if( !corpses.empty() || !disassembles.empty() || !salvageables.empty() ) {
8689 uilist kmenu;
8690 kmenu.text = _( "Choose corpse to butcher / item to disassemble" );
8691
8692 size_t i = 0;
8693 // Add corpses, disassembleables, and salvagables to the UI
8694 add_corpses( kmenu, corpses, i );
8695 add_disassemblables( kmenu, disassembly_stacks, i );
8696 if( salvage_iuse && !salvageables.empty() ) {
8697 add_salvagables( kmenu, salvage_stacks, i, *salvage_iuse );
8698 }
8699
8700 if( corpses.size() > 1 ) {
8701 kmenu.addentry( MULTIBUTCHER, true, 'b', _( "Butcher everything" ) );
8702 }
8703 if( disassembles.size() > 1 ) {
8704 int time_to_disassemble = 0;
8705 int time_to_disassemble_all = 0;
8706 for( const auto &stack : disassembly_stacks ) {
8707 const int time = recipe_dictionary::get_uncraft( stack.first->typeId() ).time;
8708 time_to_disassemble += time;
8709 time_to_disassemble_all += time * stack.second;
8710 }
8711
8712 kmenu.addentry_col( MULTIDISASSEMBLE_ONE, true, 'D', _( "Disassemble everything once" ),
8713 to_string_clipped( time_duration::from_turns( time_to_disassemble / 100 ) ) );
8714 kmenu.addentry_col( MULTIDISASSEMBLE_ALL, true, 'd', _( "Disassemble everything recursively" ),
8715 to_string_clipped( time_duration::from_turns( time_to_disassemble_all / 100 ) ) );
8716 }
8717 if( salvage_iuse && salvageables.size() > 1 ) {
8718 int time_to_salvage = 0;
8719 for( const auto &stack : salvage_stacks ) {
8720 time_to_salvage += salvage_iuse->time_to_cut_up( *stack.first ) * stack.second;
8721 }
8722
8723 kmenu.addentry_col( MULTISALVAGE, true, 'z', _( "Cut up everything" ),
8724 to_string_clipped( time_duration::from_turns( time_to_salvage / 100 ) ) );
8725 }
8726
8727 kmenu.query();
8728
8729 if( kmenu.ret < 0 || kmenu.ret >= NUM_BUTCHER_ACTIONS ) {
8730 return;
8731 }
8732
8733 ret = static_cast<size_t>( kmenu.ret );
8734 if( ret >= MULTISALVAGE && ret < NUM_BUTCHER_ACTIONS ) {
8735 butcher_select = BUTCHER_OTHER;
8736 indexer_index = ret;
8737 } else if( ret < corpses.size() ) {
8738 butcher_select = BUTCHER_CORPSE;
8739 indexer_index = ret;
8740 } else if( ret < corpses.size() + disassembly_stacks.size() ) {
8741 butcher_select = BUTCHER_DISASSEMBLE;
8742 indexer_index = ret - corpses.size();
8743 } else if( ret < corpses.size() + disassembly_stacks.size() + salvage_stacks.size() ) {
8744 butcher_select = BUTCHER_SALVAGE;
8745 indexer_index = ret - corpses.size() - disassembly_stacks.size();
8746 } else {
8747 debugmsg( "Invalid butchery index: %d", ret );
8748 return;
8749 }
8750 }
8751
8752 if( !u.has_morale_to_craft() ) {
8753 if( butcher_select == BUTCHER_CORPSE || indexer_index == MULTIBUTCHER ) {
8754 add_msg( m_info,
8755 _( "You are not in the mood and the prospect of guts and blood on your hands convinces you to turn away." ) );
8756 } else {
8757 add_msg( m_info,
8758 _( "You are not in the mood and the prospect of work stops you before you begin." ) );
8759 }
8760 return;
8761 }
8762 const auto helpers = u.get_crafting_helpers( 3 );
8763 for( const npc *np : helpers ) {
8764 add_msg( m_info, _( "%s helps with this task…" ), np->name );
8765 }
8766 switch( butcher_select ) {
8767 case BUTCHER_OTHER:
8768 switch( indexer_index ) {
8769 case MULTISALVAGE:
8770 u.assign_activity( activity_id( "ACT_LONGSALVAGE" ), 0, salvage_tool_index );
8771 break;
8772 case MULTIBUTCHER:
8773 butcher_submenu( corpses );
8774 for( map_stack::iterator &it : corpses ) {
8775 u.activity.targets.emplace_back( map_cursor( u.pos() ), &*it );
8776 }
8777 break;
8778 case MULTIDISASSEMBLE_ONE:
8779 u.disassemble_all( true );
8780 break;
8781 case MULTIDISASSEMBLE_ALL:
8782 u.disassemble_all( false );
8783 break;
8784 default:
8785 debugmsg( "Invalid butchery type: %d", indexer_index );
8786 return;
8787 }
8788 break;
8789 case BUTCHER_CORPSE: {
8790 butcher_submenu( corpses, indexer_index );
8791 u.activity.targets.emplace_back( map_cursor( u.pos() ), &*corpses[indexer_index] );
8792 }
8793 break;
8794 case BUTCHER_DISASSEMBLE: {
8795 // Pick index of first item in the disassembly stack
8796 item *const target = &*disassembly_stacks[indexer_index].first;
8797 u.disassemble( item_location( map_cursor( u.pos() ), target ), true );
8798 }
8799 break;
8800 case BUTCHER_SALVAGE: {
8801 if( !salvage_iuse || !salvage_tool ) {
8802 debugmsg( "null salve_iuse or salvage_tool" );
8803 } else {
8804 // Pick index of first item in the salvage stack
8805 item *const target = &*salvage_stacks[indexer_index].first;
8806 item_location item_loc( map_cursor( u.pos() ), target );
8807 salvage_iuse->cut_up( u, *salvage_tool, item_loc );
8808 }
8809 }
8810 break;
8811 }
8812}
string_id< activity_type > activity_id
Definition: activity_type.h:15
static std::string to_string_clipped(const int num, const clipped_unit type, const clipped_align align)
Definition: calendar.cpp:228
bool controlling_vehicle
Definition: character.h:285
player_activity activity
Definition: character.h:1580
int get_item_position(const item *it) const
Returns the item position (suitable for i_at or similar) of a specific item.
Definition: character.cpp:2403
bool has_morale_to_craft() const
Definition: crafting.cpp:330
const inventory & crafting_inventory(bool clear_path)
Definition: crafting.cpp:548
void assign_activity(const activity_id &type, int moves=calendar::INDEFINITELY_LONG, int index=-1, int pos=INT_MIN, const std::string &name="")
Legacy activity assignment, does not work for any activites using the new activity_actor class and ma...
Definition: character.cpp:9180
virtual std::string disp_name(bool possessive=false, bool capitalize_first=false) const =0
Creature * is_hostile_very_close()
Definition: game.cpp:3944
A lightweight handle to an item independent of it's location Unlike a raw pointer can be (de-)seriali...
Definition: item_location.h:23
size_t size() const
Definition: item_stack.cpp:10
iterator begin()
Definition: item_stack.cpp:28
iterator end()
Definition: item_stack.cpp:33
Definition: item.h:176
item * get_usable_item(const std::string &use_name)
Checks this item and its contents (recursively) for types that have use_function with type use_name.
Definition: item.cpp:7812
const use_function * get_use(const std::string &use_name) const
Returns the pointer to use_function with name use_name assigned to the type of this item or any of it...
Definition: item.cpp:7786
Definition: map.h:101
bool has_flag(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2287
map_stack i_at(const tripoint &p)
Definition: map.cpp:4068
bool sees_some_items(const tripoint &p, const Creature &who) const
Check if creature can see some items at p.
Definition: map.cpp:4739
std::vector< item_location > targets
void disassemble_all(bool one_pass)
Definition: crafting.cpp:2034
std::vector< npc * > get_crafting_helpers(size_t max=0) const
Returns nearby NPCs ready and willing to help with crafting or some other manual task.
Definition: crafting.cpp:2326
ret_val< bool > can_disassemble(const item &obj, const inventory &inv) const
Check if the player can disassemble an item using the current crafting inventory.
Definition: crafting.cpp:1859
bool disassemble()
Definition: crafting.cpp:1932
static const recipe & get_uncraft(const itype_id &id)
Returns disassembly recipe (or null recipe if no match)
int time
Definition: recipe.h:59
Cuts stuff up into components.
Definition: iuse_actor.h:567
bool valid_to_cut_up(const item &it) const
int cut_up(player &p, item &it, item_location &cut) const
int time_to_cut_up(const item &it) const
static constexpr time_duration from_turns(const T t)
Named constructors to get a duration representing a multiple of the named time units.
Definition: calendar.h:204
uilist: scrolling vertical list menu
Definition: ui.h:187
int ret
Definition: ui.h:412
void addentry_col(int r, bool e, int k, const std::string &str, const std::string &column, const std::string &desc="")
Definition: ui.cpp:952
std::string text
Definition: ui.h:320
void addentry(const std::string &str)
Definition: ui.cpp:932
int max_quality(const quality_id &qual) const
Return maximum tool quality level provided by instance or INT_MIN if not found.
Definition: visitable.cpp:276
std::vector< item * > items_with(const std::function< bool(const item &)> &filter)
Returns all items (including those within a container) matching the filter.
Definition: visitable.cpp:324
#define debugmsg(...)
Debug message of level DL::Error and class DC::DebugMsg, also includes the source file name and line,...
Definition: debug.h:74
static void butcher_submenu(const std::vector< map_stack::iterator > &corpses, int corpse=-1)
Definition: game.cpp:8409
static void add_salvagables(uilist &menu, const std::vector< std::pair< map_stack::iterator, int > > &stacks, size_t &menu_index, const salvage_actor &salvage_iuse)
Definition: game.cpp:8367
static void add_disassemblables(uilist &menu, const std::vector< std::pair< map_stack::iterator, int > > &stacks, size_t &menu_index)
Definition: game.cpp:8388
static std::vector< std::pair< map_stack::iterator, int > > generate_butcher_stack_display(const std::vector< map_stack::iterator > &its)
Definition: game.cpp:8320
static void add_corpses(uilist &menu, const std::vector< map_stack::iterator > &its, size_t &menu_index)
Definition: game.cpp:8355
static constexpr int MAX_ITEM_IN_SQUARE
void query(bool loop=true, int timeout=-1)
Handle input and update display.
Definition: ui.cpp:828
bool query_yn(const std::string &text)
Definition: output.cpp:698
iuse_actor * get_actor_ptr()
Definition: iuse.h:315
string_id< quality > quality_id
Definition: type_id.h:171

References _, Character::activity, add_corpses(), add_disassemblables(), add_msg(), add_salvagables(), uilist::addentry(), uilist::addentry_col(), Character::assign_activity(), item_stack::begin(), butcher_submenu(), player::can_disassemble(), Character::controlling_vehicle, Character::crafting_inventory(), salvage_actor::cut_up(), debugmsg, player::disassemble(), player::disassemble_all(), Creature::disp_name(), item_stack::end(), time_duration::from_turns(), generate_butcher_stack_display(), use_function::get_actor_ptr(), player::get_crafting_helpers(), Character::get_item_position(), recipe_dictionary::get_uncraft(), item::get_usable_item(), item::get_use(), map::has_flag(), Character::has_morale_to_craft(), map::i_at(), is_hostile_very_close(), visitable< T >::items_with(), m, m_info, MAX_ITEM_IN_SQUARE, visitable< T >::max_quality(), Character::pos(), uilist::query(), query_yn(), cata::hash64_detail::ret, uilist::ret, map::sees_some_items(), item_stack::size(), player_activity::targets, uilist::text, recipe::time, salvage_actor::time_to_cut_up(), to_string_clipped(), u, and salvage_actor::valid_to_cut_up().

Referenced by handle_action().

◆ calc_driving_offset()

void game::calc_driving_offset ( vehicle veh = nullptr)

Definition at line 1332 of file game.cpp.

1333{
1334 if( veh == nullptr || !get_option<bool>( "DRIVING_VIEW_OFFSET" ) ) {
1336 return;
1337 }
1338 const int g_light_level = static_cast<int>( light_level( u.posz() ) );
1339 const int light_sight_range = u.sight_range( g_light_level );
1340 int sight = std::max( veh_lumi( *veh ), light_sight_range );
1341
1342 // The maximal offset will leave at least this many tiles
1343 // between the PC and the edge of the main window.
1344 static const int border_range = 2;
1345 point max_offset( ( getmaxx( w_terrain ) + 1 ) / 2 - border_range - 1,
1346 ( getmaxy( w_terrain ) + 1 ) / 2 - border_range - 1 );
1347
1348 // velocity at or below this results in no offset at all
1349 static const float min_offset_vel = 1 * vehicles::vmiph_per_tile;
1350 // velocity at or above this results in maximal offset
1351 static const float max_offset_vel = std::min( max_offset.y, max_offset.x ) *
1353 float velocity = veh->velocity;
1354 rl_vec2d offset = veh->move_vec();
1355 if( !veh->skidding && veh->player_in_control( u ) &&
1356 std::abs( veh->cruise_velocity - veh->velocity ) < 7 * vehicles::vmiph_per_tile ) {
1357 // Use the cruise controlled velocity, but only if
1358 // it is not too different from the actual velocity.
1359 // The actual velocity changes too often (see above slowdown).
1360 // Using it makes would make the offset change far too often.
1361 offset = veh->face_vec();
1362 velocity = veh->cruise_velocity;
1363 }
1364 float rel_offset;
1365 if( std::fabs( velocity ) < min_offset_vel ) {
1366 rel_offset = 0;
1367 } else if( std::fabs( velocity ) > max_offset_vel ) {
1368 rel_offset = ( velocity > 0 ) ? 1 : -1;
1369 } else {
1370 rel_offset = ( velocity - min_offset_vel ) / ( max_offset_vel - min_offset_vel );
1371 }
1372 // Squeeze into the corners, by making the offset vector longer,
1373 // the PC is still in view as long as both offset.x and
1374 // offset.y are <= 1
1375 if( std::fabs( offset.x ) > std::fabs( offset.y ) && std::fabs( offset.x ) > 0.2 ) {
1376 offset.y /= std::fabs( offset.x );
1377 offset.x = ( offset.x > 0 ) ? +1 : -1;
1378 } else if( std::fabs( offset.y ) > 0.2 ) {
1379 offset.x /= std::fabs( offset.y );
1380 offset.y = offset.y > 0 ? +1 : -1;
1381 }
1382 offset.x *= rel_offset;
1383 offset.y *= rel_offset;
1384 offset.x *= max_offset.x;
1385 offset.y *= max_offset.y;
1386 // [ ----@---- ] sight=6
1387 // [ --@------ ] offset=2
1388 // [ -@------# ] offset=3
1389 // can see sights square in every direction, total visible area is
1390 // (2*sight+1)x(2*sight+1), but the window is only
1391 // getmaxx(w_terrain) x getmaxy(w_terrain)
1392 // The area outside of the window is maxoff (sight-getmax/2).
1393 // If that value is <= 0, the whole visible area fits the window.
1394 // don't apply the view offset at all.
1395 // If the offset is > maxoff, only apply at most maxoff, everything
1396 // above leads to invisible area in front of the car.
1397 // It will display (getmax/2+offset) squares in one direction and
1398 // (getmax/2-offset) in the opposite direction (centered on the PC).
1399 const point maxoff( ( sight * 2 + 1 - getmaxx( w_terrain ) ) / 2,
1400 ( sight * 2 + 1 - getmaxy( w_terrain ) ) / 2 );
1401 if( maxoff.x <= 0 ) {
1402 offset.x = 0;
1403 } else if( offset.x > 0 && offset.x > maxoff.x ) {
1404 offset.x = maxoff.x;
1405 } else if( offset.x < 0 && -offset.x > maxoff.x ) {
1406 offset.x = -maxoff.x;
1407 }
1408 if( maxoff.y <= 0 ) {
1409 offset.y = 0;
1410 } else if( offset.y > 0 && offset.y > maxoff.y ) {
1411 offset.y = maxoff.y;
1412 } else if( offset.y < 0 && -offset.y > maxoff.y ) {
1413 offset.y = -maxoff.y;
1414 }
1415
1416 // Turn the offset into a vector that increments the offset toward the desired position
1417 // instead of setting it there instantly, should smooth out jerkiness.
1418 const point offset_difference( -driving_view_offset + point( offset.x, offset.y ) );
1419
1420 const point offset_sign( ( offset_difference.x < 0 ) ? -1 : 1,
1421 ( offset_difference.y < 0 ) ? -1 : 1 );
1422 // Shift the current offset in the direction of the calculated offset by one tile
1423 // per draw event, but snap to calculated offset if we're close enough to avoid jitter.
1424 offset.x = ( std::abs( offset_difference.x ) > 1 ) ?
1425 ( driving_view_offset.x + offset_sign.x ) : offset.x;
1426 offset.y = ( std::abs( offset_difference.y ) > 1 ) ?
1427 ( driving_view_offset.y + offset_sign.y ) : offset.y;
1428
1429 set_driving_view_offset( point( offset.x, offset.y ) );
1430}
int posz() const override
Definition: character.h:844
int sight_range(int light_level) const override
Returns the player's sight range.
Definition: character.cpp:712
point driving_view_offset
Definition: game.h:1045
catacurses::window w_terrain
Definition: game.h:1035
void set_driving_view_offset(const point &p)
Definition: game.cpp:1689
unsigned char light_level(int zlev) const
Returns coarse number-of-squares of visibility at the current light level.
Definition: game.cpp:3916
rl_vec2d move_vec() const
rl_vec2d face_vec() const
bool skidding
Definition: vehicle.h:1980
bool player_in_control(const Character &p) const
Definition: vehicle.cpp:277
int velocity
Definition: vehicle.h:1899
int cruise_velocity
Definition: vehicle.h:1901
static int veh_lumi(vehicle &veh)
Definition: game.cpp:1314
int getmaxx(const window &win)
Definition: ncurses_def.cpp:58
int getmaxy(const window &win)
Definition: ncurses_def.cpp:63
quantity< V, U > fabs(quantity< V, U > q)
Definition: units_def.h:136
constexpr float vmiph_per_tile
Definition: vehicle.h:68
static constexpr point point_zero
Definition: point.h:274
Definition: point.h:35
int y
Definition: point.h:39
int x
Definition: point.h:38
float y
Definition: point_float.h:13
float x
Definition: point_float.h:12

References vehicle::cruise_velocity, driving_view_offset, units::fabs(), vehicle::face_vec(), catacurses::getmaxx(), catacurses::getmaxy(), light_level(), vehicle::move_vec(), vehicle::player_in_control(), point_zero, Character::posz(), set_driving_view_offset(), Character::sight_range(), vehicle::skidding, u, veh_lumi(), vehicle::velocity, vehicles::vmiph_per_tile, w_terrain, point::x, rl_vec2d::x, point::y, and rl_vec2d::y.

Referenced by do_turn().

◆ cancel_activity_or_ignore_query()

bool game::cancel_activity_or_ignore_query ( distraction_type  type,
const std::string &  text 
)

Asks if the player wants to cancel their activity and if so cancels it.

Additionally checks if the player wants to ignore further distractions.

Definition at line 1790 of file game.cpp.

1791{
1793 if( u.has_distant_destination() ) {
1794 if( cancel_auto_move( u, text ) ) {
1795 return true;
1796 } else {
1798 return false;
1799 }
1800 }
1802 return false;
1803 }
1804 const bool force_uc = get_option<bool>( "FORCE_CAPITAL_YN" );
1805 const auto &allow_key = force_uc ? input_context::disallow_lower_case
1807
1808 const auto &action = query_popup()
1809 .context( "CANCEL_ACTIVITY_OR_IGNORE_QUERY" )
1810 .message( force_uc ?
1811 pgettext( "cancel_activity_or_ignore_query",
1812 "<color_light_red>%s %s (Case Sensitive)</color>" ) :
1813 pgettext( "cancel_activity_or_ignore_query",
1814 "<color_light_red>%s %s</color>" ),
1815 text, u.activity.get_stop_phrase() )
1816 .option( "YES", allow_key )
1817 .option( "NO", allow_key )
1818 .option( "IGNORE", allow_key )
1819 .query()
1820 .action;
1821
1822 if( action == "YES" ) {
1824 return true;
1825 }
1826 if( action == "IGNORE" ) {
1828 for( auto &activity : u.backlog ) {
1829 activity.ignore_distraction( type );
1830 }
1831 }
1832
1835
1836 return false;
1837}
void set_destination(const std::vector< tripoint > &route, const player_activity &new_destination_activity=player_activity())
void cancel_activity()
Definition: character.cpp:9223
std::vector< tripoint > & get_auto_move_route()
std::list< player_activity > backlog
Definition: character.h:1581
bool has_distant_destination() const
static const input_event_filter allow_all_keys
Definition: input.h:541
static const input_event_filter disallow_lower_case
Definition: input.h:540
bool is_distraction_ignored(distraction_type type) const
std::string get_stop_phrase() const
void ignore_distraction(distraction_type type)
UI class for displaying messages or querying player input with popups.
Definition: popup.h:39
query_popup & context(const std::string &cat)
Specify the input context.
Definition: popup.cpp:21
query_popup & option(const std::string &opt)
Specify an action as an option.
Definition: popup.cpp:28
result query()
Query until a valid action or an error happens and return the result.
Definition: popup.cpp:348
query_popup & message(const std::string &fmt, Args &&... args)
Specify the query message.
Definition: popup.h:91
@ action
Definition: dialogue.h:36
@ type
Definition: enums.h:75
static bool cancel_auto_move(player &p, const std::string &text)
Definition: game.cpp:1777
void redraw()
Definition: ui_manager.cpp:285
void refresh_display()
Make changes made to the display visible to the user immediately.
std::string action
Definition: popup.h:68
const char * pgettext(const char *context, const char *msgid)

References action, query_popup::result::action, Character::activity, input_context::allow_all_keys, Character::backlog, Character::cancel_activity(), cancel_auto_move(), query_popup::context(), input_context::disallow_lower_case, Character::get_auto_move_route(), player_activity::get_stop_phrase(), Character::has_distant_destination(), player_activity::ignore_distraction(), invalidate_main_ui_adaptor(), player_activity::is_distraction_ignored(), query_popup::message(), query_popup::option(), pgettext(), query_popup::query(), ui_manager::redraw(), refresh_display(), Character::set_destination(), type, and u.

Referenced by mon_info_update(), monmove(), and process_voluntary_act_interrupt().

◆ cancel_activity_query()

bool game::cancel_activity_query ( const std::string &  text)

Asks if the player wants to cancel their activity, and if so cancels it.

Definition at line 1839 of file game.cpp.

1840{
1842 if( u.has_distant_destination() ) {
1843 if( cancel_auto_move( u, text ) ) {
1844 return true;
1845 } else {
1847 return false;
1848 }
1849 }
1850 if( !u.activity ) {
1851 return false;
1852 }
1853 if( query_yn( "%s %s", text, u.activity.get_stop_phrase() ) ) {
1857 return true;
1858 }
1859 return false;
1860}
void clear_destination()
void resume_backlog_activity()
Definition: character.cpp:9255

References Character::activity, Character::cancel_activity(), cancel_auto_move(), Character::clear_destination(), Character::get_auto_move_route(), player_activity::get_stop_phrase(), Character::has_distant_destination(), invalidate_main_ui_adaptor(), query_yn(), Character::resume_backlog_activity(), Character::set_destination(), and u.

Referenced by handle_key_blocking_activity().

◆ catch_a_monster()

void game::catch_a_monster ( monster fish,
const tripoint pos,
player p,
const time_duration catch_duration 
)

Picks and spawns a random fish from the remaining fish list when a fish is caught.

Definition at line 1763 of file game.cpp.

1765{
1766 //spawn the corpse, rotten by a part of the duration
1768 catch_duration ) ) );
1769 if( u.sees( pos ) ) {
1770 u.add_msg_if_player( m_good, _( "You caught a %s." ), fish->type->nname() );
1771 }
1772 //quietly kill the caught
1773 fish->no_corpse_quiet = true;
1774 fish->die( p );
1775}
bool sees(const tripoint &t, bool is_player=false, int range_mod=0) const override
static item make_corpse(const mtype_id &mt=string_id< mtype >::NULL_ID(), time_point turn=calendar::turn, const std::string &name="", int upgrade_time=-1)
Make a corpse of the given monster type.
Definition: item.cpp:504
item & add_item_or_charges(const tripoint &pos, item obj, bool overflow=true)
Adds an item to map tile or stacks charges.
Definition: map.cpp:4213
bool no_corpse_quiet
Definition: monster.h:482
void die(Creature *killer) override
Empty function.
Definition: monster.cpp:2243
const mtype * type
Definition: monster.h:478
void add_msg_if_player(const std::string &msg) const override
Definition: player.cpp:4368
time_point turn
Definition: calendar.cpp:36
mtype_id id
Definition: mtype.h:240
std::string nname(unsigned int quantity=1) const
Definition: mtype.cpp:65

References _, map::add_item_or_charges(), player::add_msg_if_player(), monster::die(), mtype::id, m, m_good, item::make_corpse(), mtype::nname(), monster::no_corpse_quiet, rng(), Character::sees(), calendar::turn, monster::type, and u.

◆ chat()

void game::chat ( )
private

Definition at line 393 of file npctalk.cpp.

394{
395 int volume = g->u.get_shout_volume();
396
397 const std::vector<npc *> available = get_npcs_if( [&]( const npc & guy ) {
398 // TODO: Get rid of the z-level check when z-level vision gets "better"
399 return u.posz() == guy.posz() && u.sees( guy.pos() ) &&
400 rl_dist( u.pos(), guy.pos() ) <= SEEX * 2;
401 } );
402 const int available_count = available.size();
403 const std::vector<npc *> followers = get_npcs_if( [&]( const npc & guy ) {
404 return guy.is_player_ally() && guy.is_following() && guy.can_hear( u.pos(), volume );
405 } );
406 const int follower_count = followers.size();
407 const std::vector<npc *> guards = get_npcs_if( [&]( const npc & guy ) {
408 return guy.mission == NPC_MISSION_GUARD_ALLY &&
409 guy.companion_mission_role_id != "FACTION_CAMP" &&
410 guy.can_hear( u.pos(), volume );
411 } );
412 const int guard_count = guards.size();
413
414 if( g->u.has_trait( trait_PROF_FOODP ) && !( g->u.is_wearing( itype_id( "foodperson_mask" ) ) ||
415 g->u.is_wearing( itype_id( "foodperson_mask_on" ) ) ) ) {
416 g->u.add_msg_if_player( m_warning, _( "You can't speak without your face!" ) );
417 return;
418 }
419 std::vector<vehicle *> animal_vehicles;
420 std::vector<vehicle *> following_vehicles;
421 std::vector<vehicle *> magic_vehicles;
422 std::vector<vehicle *> magic_following_vehicles;
423 for( auto &veh : g->m.get_vehicles() ) {
424 auto &v = veh.v;
425 if( v->has_engine_type( fuel_type_animal, false ) && v->is_owned_by( g->u ) ) {
426 animal_vehicles.push_back( v );
427 if( v->is_following ) {
428 following_vehicles.push_back( v );
429 }
430 }
431 if( v->magic ) {
432 for( const vpart_reference &vp : v->get_all_parts() ) {
433 const vpart_info &vpi = vp.info();
434 if( vpi.has_flag( "MAGIC_FOLLOW" ) ) {
435 magic_vehicles.push_back( v );
436 if( v->is_following ) {
437 magic_following_vehicles.push_back( v );
438 }
439 break;
440 }
441 }
442 }
443 }
444
445 uilist nmenu;
446 nmenu.text = std::string( _( "What do you want to do?" ) );
447
448 if( !available.empty() ) {
449 nmenu.addentry( NPC_CHAT_TALK, true, 't', available_count == 1 ?
450 string_format( _( "Talk to %s" ), available.front()->name ) :
451 _( "Talk to…" )
452 );
453 }
454 nmenu.addentry( NPC_CHAT_YELL, true, 'a', _( "Yell" ) );
455 nmenu.addentry( NPC_CHAT_SENTENCE, true, 'b', _( "Yell a sentence" ) );
456 if( !animal_vehicles.empty() ) {
458 _( "Whistle at your animals pulling vehicles to follow you." ) );
459 }
460 if( !magic_vehicles.empty() ) {
462 _( "Utter a magical command that will order your magical vehicles to follow you." ) );
463 }
464 if( !magic_following_vehicles.empty() ) {
466 _( "Utter a magical command that will order your magical vehicles to stop following you." ) );
467 }
468 if( !following_vehicles.empty() ) {
470 _( "Whistle at your animals pulling vehicles to stop following you." ) );
471 }
472 if( !guards.empty() ) {
473 nmenu.addentry( NPC_CHAT_FOLLOW, true, 'f', guard_count == 1 ?
474 string_format( _( "Tell %s to follow" ), guards.front()->name ) :
475 _( "Tell someone to follow…" )
476 );
477 }
478 if( !followers.empty() ) {
479 nmenu.addentry( NPC_CHAT_GUARD, true, 'g', follower_count == 1 ?
480 string_format( _( "Tell %s to guard" ), followers.front()->name ) :
481 _( "Tell someone to guard…" )
482 );
483 nmenu.addentry( NPC_CHAT_AWAKE, true, 'w', _( "Tell everyone on your team to wake up" ) );
484 nmenu.addentry( NPC_CHAT_MOUNT, true, 'M', _( "Tell everyone on your team to mount up" ) );
485 nmenu.addentry( NPC_CHAT_DISMOUNT, true, 'm', _( "Tell everyone on your team to dismount" ) );
486 nmenu.addentry( NPC_CHAT_DANGER, true, 'D',
487 _( "Tell everyone on your team to prepare for danger" ) );
488 nmenu.addentry( NPC_CHAT_CLEAR_OVERRIDES, true, 'r',
489 _( "Tell everyone on your team to relax (Clear Overrides)" ) );
490 nmenu.addentry( NPC_CHAT_ORDERS, true, 'o', _( "Tell everyone on your team to temporarily…" ) );
491 }
492 std::string message;
493 std::string yell_msg;
494 bool is_order = true;
495 nmenu.query();
496
497 if( nmenu.ret < 0 ) {
498 return;
499 }
500
501 switch( nmenu.ret ) {
502 case NPC_CHAT_TALK: {
503 const int npcselect = npc_select_menu( available, _( "Talk to whom?" ), false );
504 if( npcselect < 0 ) {
505 return;
506 }
507 available[npcselect]->talk_to_u();
508 break;
509 }
510 case NPC_CHAT_YELL:
511 is_order = false;
512 message = _( "loudly." );
513 break;
514 case NPC_CHAT_SENTENCE: {
515 std::string popupdesc = _( "Enter a sentence to yell" );
517 popup.title( _( "Yell a sentence" ) )
518 .width( 64 )
519 .description( popupdesc )
520 .identifier( "sentence" )
521 .max_length( 128 )
522 .query();
523 yell_msg = popup.text();
524 is_order = false;
525 break;
526 }
527 case NPC_CHAT_GUARD: {
528 const int npcselect = npc_select_menu( followers, _( "Who should guard here?" ) );
529 if( npcselect < 0 ) {
530 return;
531 }
532 if( npcselect == follower_count ) {
533 for( npc *them : followers ) {
535 }
536 yell_msg = _( "Everyone guard here!" );
537 } else {
538 talk_function::assign_guard( *followers[npcselect] );
539 yell_msg = string_format( _( "Guard here, %s!" ), followers[npcselect]->name );
540 }
541 break;
542 }
543 case NPC_CHAT_FOLLOW: {
544 const int npcselect = npc_select_menu( guards, _( "Who should follow you?" ) );
545 if( npcselect < 0 ) {
546 return;
547 }
548 if( npcselect == guard_count ) {
549 for( npc *them : guards ) {
551 }
552 yell_msg = _( "Everyone follow me!" );
553 } else {
554 talk_function::stop_guard( *guards[npcselect] );
555 yell_msg = string_format( _( "Follow me, %s!" ), guards[npcselect]->name );
556 }
557 break;
558 }
559 case NPC_CHAT_AWAKE:
560 for( npc *them : followers ) {
561 talk_function::wake_up( *them );
562 }
563 yell_msg = _( "Stay awake!" );
564 break;
565 case NPC_CHAT_MOUNT:
566 for( npc *them : followers ) {
567 if( them->has_effect( effect_riding ) ) {
568 continue;
569 }
571 }
572 yell_msg = _( "Mount up!" );
573 break;
575 for( npc *them : followers ) {
576 if( them->has_effect( effect_riding ) ) {
577 them->npc_dismount();
578 }
579 }
580 yell_msg = _( "Dismount!" );
581 break;
582 case NPC_CHAT_DANGER:
583 for( npc *them : followers ) {
584 them->rules.set_danger_overrides();
585 }
586 yell_msg = _( "We're in danger. Stay awake, stay close, don't go wandering off, "
587 "and don't open any doors." );
588 break;
590 for( npc *p : followers ) {
592 }
593 yell_msg = _( "As you were." );
594 break;
595 case NPC_CHAT_ORDERS:
596 npc_temp_orders_menu( followers );
597 break;
600 break;
603 break;
606 break;
609 break;
610 default:
611 return;
612 }
613
614 if( !yell_msg.empty() ) {
615 message = string_format( "\"%s\"", yell_msg );
616 }
617 if( !message.empty() ) {
618 add_msg( _( "You yell %s" ), message );
619 u.shout( string_format( _( "%s yelling %s" ), u.disp_name(), message ), is_order );
620 }
621
622 u.moves -= 100;
623}
std::string disp_name(bool possessive=false, bool capitalize_first=false) const override
Returns either "you" or the player's name.
Definition: character.cpp:539
void shout(std::string msg="", bool order=false)
Definition: character.cpp:7720
bool can_hear(const tripoint &source, int volume) const
int moves
Definition: creature.h:569
std::string companion_mission_role_id
Definition: npc.h:1318
npc_mission mission
Definition: npc.h:1325
bool is_player_ally() const
Definition: npc.cpp:1984
bool is_following() const
Definition: npc.cpp:2015
Shows a window querying the user for input.
bool has_flag(const std::string &flag) const
Definition: veh_type.h:336
This is a wrapper over a vehicle pointer and a reference to a part of it.
int rl_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:519
static constexpr int SEEX
std::string message
Definition: mapgen.cpp:403
std::string name(type dir)
Get Human readable name of a direction.
Definition: overmap.cpp:4108
void wake_up(npc &)
void find_mount(npc &)
void clear_overrides(npc &p)
void stop_guard(npc &)
void assign_guard(npc &)
quantity< int, volume_in_milliliter_tag > volume
Definition: units_volume.h:16
@ NPC_MISSION_GUARD_ALLY
Definition: npc.h:187
static const efftype_id effect_riding("riding")
static const trait_id trait_PROF_FOODP("PROF_FOODP")
static int npc_select_menu(const std::vector< npc * > &npc_list, const std::string &prompt, const bool everyone=true)
Definition: npctalk.cpp:219
static void tell_magic_veh_stop_following()
Definition: npctalk.cpp:376
static void tell_veh_stop_following()
Definition: npctalk.cpp:339
static void assign_veh_to_follow()
Definition: npctalk.cpp:350
static void npc_temp_orders_menu(const std::vector< npc * > &npc_list)
Definition: npctalk.cpp:251
static const itype_id fuel_type_animal("animal")
@ NPC_CHAT_MOUNT
Definition: npctalk.cpp:199
@ NPC_CHAT_COMMAND_MAGIC_VEHICLE_STOP_FOLLOW
Definition: npctalk.cpp:213
@ NPC_CHAT_YELL
Definition: npctalk.cpp:194
@ NPC_CHAT_FOLLOW
Definition: npctalk.cpp:197
@ NPC_CHAT_GUARD
Definition: npctalk.cpp:196
@ NPC_CHAT_DISMOUNT
Definition: npctalk.cpp:200
@ NPC_CHAT_ANIMAL_VEHICLE_FOLLOW
Definition: npctalk.cpp:210
@ NPC_CHAT_ORDERS
Definition: npctalk.cpp:202
@ NPC_CHAT_SENTENCE
Definition: npctalk.cpp:195
@ NPC_CHAT_CLEAR_OVERRIDES
Definition: npctalk.cpp:209
@ NPC_CHAT_DANGER
Definition: npctalk.cpp:201
@ NPC_CHAT_AWAKE
Definition: npctalk.cpp:198
@ NPC_CHAT_ANIMAL_VEHICLE_STOP_FOLLOW
Definition: npctalk.cpp:211
@ NPC_CHAT_TALK
Definition: npctalk.cpp:193
@ NPC_CHAT_COMMAND_MAGIC_VEHICLE_FOLLOW
Definition: npctalk.cpp:212
static void tell_magic_veh_to_follow()
Definition: npctalk.cpp:360
int popup(const std::string &text, PopupFlags flags)
Definition: output.cpp:764

References _, add_msg(), uilist::addentry(), talk_function::assign_guard(), assign_veh_to_follow(), available, Character::can_hear(), talk_function::clear_overrides(), npc::companion_mission_role_id, Character::disp_name(), effect_riding, talk_function::find_mount(), fuel_type_animal, g, get_npcs_if(), vpart_info::has_flag(), npc::is_following(), npc::is_player_ally(), m_warning, mapgen_defer::message, npc::mission, Creature::moves, om_direction::name(), NPC_CHAT_ANIMAL_VEHICLE_FOLLOW, NPC_CHAT_ANIMAL_VEHICLE_STOP_FOLLOW, NPC_CHAT_AWAKE, NPC_CHAT_CLEAR_OVERRIDES, NPC_CHAT_COMMAND_MAGIC_VEHICLE_FOLLOW, NPC_CHAT_COMMAND_MAGIC_VEHICLE_STOP_FOLLOW, NPC_CHAT_DANGER, NPC_CHAT_DISMOUNT, NPC_CHAT_FOLLOW, NPC_CHAT_GUARD, NPC_CHAT_MOUNT, NPC_CHAT_ORDERS, NPC_CHAT_SENTENCE, NPC_CHAT_TALK, NPC_CHAT_YELL, NPC_MISSION_GUARD_ALLY, npc_select_menu(), npc_temp_orders_menu(), popup(), Character::pos(), Character::posz(), uilist::query(), uilist::ret, rl_dist(), Character::sees(), SEEX, Character::shout(), talk_function::stop_guard(), string_format(), tell_magic_veh_stop_following(), tell_magic_veh_to_follow(), tell_veh_stop_following(), uilist::text, trait_PROF_FOODP, u, and talk_function::wake_up().

Referenced by handle_action().

◆ check_mod_data()

bool game::check_mod_data ( const std::vector< mod_id > &  opts,
loading_ui ui 
)

Check if mods can be successfully loaded.

Parameters
optscheck specific mods (or all if unspecified)
Returns
whether all mods were successfully loaded

Definition at line 343 of file game.cpp.

344{
345 auto &tree = world_generator->get_mod_manager().get_tree();
346
347 // deduplicated list of mods to check
348 std::set<mod_id> check( opts.begin(), opts.end() );
349
350 // if no specific mods specified check all non-obsolete mods
351 if( check.empty() ) {
352 for( const mod_id &e : world_generator->get_mod_manager().all_mods() ) {
353 if( !e->obsolete ) {
354 check.emplace( e );
355 }
356 }
357 }
358
359 if( check.empty() ) {
360 world_generator->set_active_world( nullptr );
361 world_generator->init();
362 const std::vector<mod_id> mods_empty;
363 WORLDPTR test_world = world_generator->make_new_world( mods_empty );
364 world_generator->set_active_world( test_world );
365
366 // if no loadable mods then test core data only
367 try {
370 } catch( const std::exception &err ) {
371 std::cerr << "Error loading data from json: " << err.what() << std::endl;
372 }
373
374 std::string world_name = world_generator->active_world->world_name;
375 world_generator->delete_world( world_name, true );
376
379 }
380
381 for( const auto &e : check ) {
382 world_generator->set_active_world( nullptr );
383 world_generator->init();
384 const std::vector<mod_id> mods_empty;
385 WORLDPTR test_world = world_generator->make_new_world( mods_empty );
386 if( !test_world ) {
387 std::cerr << "Failed to generate test world." << std::endl;
388 return false;
389 }
390 world_generator->set_active_world( test_world );
391
392 if( !e.is_valid() ) {
393 std::cerr << "Unknown mod: " << e.str() << std::endl;
394 return false;
395 }
396
397 const MOD_INFORMATION &mod = *e;
398
399 if( !tree.is_available( mod.ident ) ) {
400 std::cerr << "Missing dependencies: " << mod.name() << "\n"
401 << tree.get_node( mod.ident )->s_errors() << std::endl;
402 return false;
403 }
404
405 std::cout << "Checking mod " << mod.name() << " [" << mod.ident.str() << "]" << std::endl;
406
407 try {
409
410 // Load any dependencies
411 for( auto &dep : tree.get_dependencies_of_X_as_strings( mod.ident ) ) {
412 load_data_from_dir( dep->path, dep->ident.str(), ui );
413 }
414
415 // Load mod itself
416 load_data_from_dir( mod.path, mod.ident.str(), ui );
418 } catch( const std::exception &err ) {
419 std::cerr << "Error loading data: " << err.what() << std::endl;
420 }
421
422 std::string world_name = world_generator->active_world->world_name;
423 world_generator->delete_world( world_name, true );
424
427 }
428 return true;
429}
void finalize_loaded_data(loading_ui &ui)
Called to finalize the loaded data.
Definition: init.cpp:626
static DynamicDataLoader & get_instance()
Returns the single instance of this class.
Definition: init.cpp:111
void load_data_from_dir(const std::string &path, const std::string &src, loading_ui &ui)
Loads dynamic data from the given directory.
Definition: game.cpp:445
void load_core_data(loading_ui &ui)
Loads core dynamic data.
Definition: game.cpp:436
void reset()
Delete all buffered submaps.
Definition: mapbuffer.cpp:49
int check(unformattable)
Definition: fmtlib_core.h:1610
Definition: overmap_ui.h:17
overmapbuffer overmap_buffer

References detail::check(), overmapbuffer::clear(), DynamicDataLoader::finalize_loaded_data(), DynamicDataLoader::get_instance(), load_core_data(), load_data_from_dir(), MAPBUFFER, overmap_buffer, mapbuffer::reset(), and world_generator.

◆ check_near_zone()

bool game::check_near_zone ( const zone_type_id type,
const tripoint where 
) const

Checks whether or not there is a zone of particular type nearby.

Definition at line 6289 of file game.cpp.

6290{
6291 return zone_manager::get_manager().has_near( type, m.getabs( where ) );
6292}
static zone_manager & get_manager()
Definition: clzones.cpp:125
bool has_near(const zone_type_id &type, const tripoint &where, int range=MAX_DISTANCE, const faction_id &fac=your_fac) const
Definition: clzones.cpp:702

References zone_manager::get_manager(), map::getabs(), zone_manager::has_near(), m, and type.

◆ check_safe_mode_allowed()

bool game::check_safe_mode_allowed ( bool  repeat_safe_mode_warnings = true)

Check whether movement is allowed according to safe mode settings.

Returns
true if the movement is allowed, otherwise false.

Definition at line 9109 of file game.cpp.

9110{
9111 if( !repeat_safe_mode_warnings && safe_mode_warning_logged ) {
9112 // Already warned player since safe_mode_warning_logged is set.
9113 return false;
9114 }
9115
9116 std::string msg_ignore = press_x( ACTION_IGNORE_ENEMY );
9117 if( !msg_ignore.empty() ) {
9118 std::wstring msg_ignore_wide = utf8_to_wstr( msg_ignore );
9119 // Operate on a wide-char basis to prevent corrupted multi-byte string
9120 msg_ignore_wide[0] = towlower( msg_ignore_wide[0] );
9121 msg_ignore = wstr_to_utf8( msg_ignore_wide );
9122 }
9123
9125 // Automatic and mandatory safemode. Make BLOODY sure the player notices!
9126 if( u.get_int_base() < 5 || u.has_trait( trait_id( "PROF_CHURL" ) ) ) {
9128 _( "There's an angry red dot on your body, %s to brush it off." ), msg_ignore );
9129 } else {
9131 _( "You are being laser-targeted, %s to ignore." ), msg_ignore );
9132 }
9134 return false;
9135 }
9136 if( safe_mode != SAFE_MODE_STOP ) {
9137 return true;
9138 }
9139 // Currently driving around, ignore the monster, they have no chance against a proper car anyway (-:
9140 if( u.controlling_vehicle && !get_option<bool>( "SAFEMODEVEH" ) ) {
9141 return true;
9142 }
9143 // Monsters around and we don't want to run
9144 std::string spotted_creature_name;
9145 const monster_visible_info &mon_visible = u.get_mon_visible();
9146 const auto &new_seen_mon = mon_visible.new_seen_mon;
9147
9148 if( new_seen_mon.empty() ) {
9149 // naming consistent with code in game::mon_info
9150 spotted_creature_name = _( "a survivor" );
9152 } else {
9153 spotted_creature_name = new_seen_mon.back()->name();
9154 get_safemode().lastmon_whitelist = spotted_creature_name;
9155 }
9156
9157 std::string whitelist;
9158 if( !get_safemode().empty() ) {
9159 whitelist = string_format( _( " or %s to whitelist the monster" ),
9161 }
9162
9163 const std::string msg_safe_mode = press_x( ACTION_TOGGLE_SAFEMODE );
9165 _( "Spotted %1$s--safe mode is on! (%2$s to turn it off, %3$s to ignore monster%4$s)" ),
9166 spotted_creature_name, msg_safe_mode, msg_ignore, whitelist );
9168 return false;
9169}
std::string press_x(action_id act)
Definition: action.cpp:451
@ ACTION_IGNORE_ENEMY
Ignore the enemy that triggered safemode.
Definition: action.h:221
@ ACTION_WHITELIST_ENEMY
Whitelist the enemy that triggered safemode.
Definition: action.h:223
@ ACTION_TOGGLE_SAFEMODE
Turn safemode on/off, while leaving autosafemode intact.
Definition: action.h:215
std::wstring utf8_to_wstr(const std::string &str)
std::string wstr_to_utf8(const std::wstring &wstr)
bool has_trait(const trait_id &b) const override
Returns true if the player has the entered trait.
Definition: mutation.cpp:103
bool has_effect(const efftype_id &eff_id, body_part bp=num_bp) const
Check if creature has the matching effect.
Definition: creature.cpp:1176
int get_int_base() const override
Definition: avatar.cpp:1006
monster_visible_info & get_mon_visible()
Definition: avatar.h:210
std::string lastmon_whitelist
Definition: safemode_ui.h:87
std::string npc_type_name()
Definition: safemode_ui.cpp:44
@ gmf_bypass_cooldown
Definition: enums.h:281
static const efftype_id effect_laserlocked("laserlocked")
@ SAFE_MODE_STOP
Definition: game.h:79
safemode & get_safemode()
Definition: safemode_ui.cpp:33
Structure allowing a combination of game_message_type and game_message_flags.
Definition: enums.h:286
std::vector< shared_ptr_fast< monster > > new_seen_mon
Definition: avatar.h:40

References _, ACTION_IGNORE_ENEMY, ACTION_TOGGLE_SAFEMODE, ACTION_WHITELIST_ENEMY, add_msg(), Character::controlling_vehicle, effect_laserlocked, avatar::get_int_base(), avatar::get_mon_visible(), get_safemode(), gmf_bypass_cooldown, Creature::has_effect(), Character::has_trait(), safemode::lastmon_whitelist, m_warning, monster_visible_info::new_seen_mon, safemode::npc_type_name(), press_x(), safe_mode, SAFE_MODE_STOP, safe_mode_warning_logged, string_format(), u, utf8_to_wstr(), and wstr_to_utf8().

Referenced by handle_action().

◆ check_zone()

bool game::check_zone ( const zone_type_id type,
const tripoint where 
) const

Definition at line 6284 of file game.cpp.

6285{
6286 return zone_manager::get_manager().has( type, m.getabs( where ) );
6287}
bool has(const zone_type_id &type, const tripoint &where, const faction_id &fac=your_fac) const
Definition: clzones.cpp:694

References zone_manager::get_manager(), map::getabs(), zone_manager::has(), m, and type.

Referenced by place_player().

◆ cleanup_at_end()

bool game::cleanup_at_end ( )

Definition at line 1028 of file game.cpp.

1029{
1030 if( uquit == QUIT_DIED || uquit == QUIT_SUICIDE ) {
1031 // Put (non-hallucinations) into the overmap so they are not lost.
1032 for( monster &critter : all_monsters() ) {
1033 despawn_monster( critter );
1034 }
1035 // Reset NPC factions and disposition
1037 // Save the factions', missions and set the NPC's overmap coordinates
1038 // Npcs are saved in the overmap.
1039 save_factions_missions_npcs(); //missions need to be saved as they are global for all saves.
1040 // save artifacts.
1042
1043 // and the overmap, and the local map.
1044 save_maps(); //Omap also contains the npcs who need to be saved.
1045 }
1046
1047 if( uquit == QUIT_DIED || uquit == QUIT_SUICIDE ) {
1048 std::vector<std::string> vRip;
1049
1050 int iMaxWidth = 0;
1051 int iNameLine = 0;
1052 int iInfoLine = 0;
1053
1056 if( !( u.has_trait( trait_id( "CANNIBAL" ) ) || u.has_trait( trait_id( "PSYCHOPATH" ) ) ) ) {
1057 vRip.emplace_back( " _______ ___" );
1058 vRip.emplace_back( " < `/ |" );
1059 vRip.emplace_back( " > _ _ (" );
1060 vRip.emplace_back( " | |_) | |_) |" );
1061 vRip.emplace_back( " | | \\ | | |" );
1062 vRip.emplace_back( " ______.__%_| |_________ __" );
1063 vRip.emplace_back( " _/ \\| |" );
1064 iNameLine = vRip.size();
1065 vRip.emplace_back( "| <" );
1066 vRip.emplace_back( "| |" );
1067 iMaxWidth = utf8_width( vRip.back() );
1068 vRip.emplace_back( "| |" );
1069 vRip.emplace_back( "|_____.-._____ __/|_________|" );
1070 vRip.emplace_back( " | |" );
1071 iInfoLine = vRip.size();
1072 vRip.emplace_back( " | |" );
1073 vRip.emplace_back( " | <" );
1074 vRip.emplace_back( " | |" );
1075 vRip.emplace_back( " | _ |" );
1076 vRip.emplace_back( " |__/ |" );
1077 vRip.emplace_back( " % / `--. |%" );
1078 vRip.emplace_back( " * .%%| -< @%%%" ); // NOLINT(cata-text-style)
1079 vRip.emplace_back( " `\\%`@| |@@%@%%" );
1080 vRip.emplace_back( " .%%%@@@|% ` % @@@%%@%%%%" );
1081 vRip.emplace_back( " _.%%%%%%@@@@@@%%%__/\\%@@%%@@@@@@@%%%%%%" );
1082
1083 } else {
1084 vRip.emplace_back( " _______ ___" );
1085 vRip.emplace_back( " | \\/ |" );
1086 vRip.emplace_back( " | |" );
1087 vRip.emplace_back( " | |" );
1088 iInfoLine = vRip.size();
1089 vRip.emplace_back( " | |" );
1090 vRip.emplace_back( " | |" );
1091 vRip.emplace_back( " | |" );
1092 vRip.emplace_back( " | |" );
1093 vRip.emplace_back( " | <" );
1094 vRip.emplace_back( " | _ |" );
1095 vRip.emplace_back( " |__/ |" );
1096 vRip.emplace_back( " ______.__%_| |__________ _" );
1097 vRip.emplace_back( " _/ \\| \\" );
1098 iNameLine = vRip.size();
1099 vRip.emplace_back( "| <" );
1100 vRip.emplace_back( "| |" );
1101 iMaxWidth = utf8_width( vRip.back() );
1102 vRip.emplace_back( "| |" );
1103 vRip.emplace_back( "|_____.-._______ __/|__________|" );
1104 vRip.emplace_back( " % / `_-. _ |%" );
1105 vRip.emplace_back( " * .%%| |_) | |_)< @%%%" ); // NOLINT(cata-text-style)
1106 vRip.emplace_back( " `\\%`@| | \\ | | |@@%@%%" );
1107 vRip.emplace_back( " .%%%@@@|% ` % @@@%%@%%%%" );
1108 vRip.emplace_back( " _.%%%%%%@@@@@@%%%__/\\%@@%%@@@@@@@%%%%%%" );
1109 }
1110 } else {
1111 vRip.emplace_back( R"( _________ ____ )" );
1112 vRip.emplace_back( R"( _/ `/ \_ )" );
1113 vRip.emplace_back( R"( _/ _ _ \_. )" );
1114 vRip.emplace_back( R"( _%\ |_) | |_) \_ )" );
1115 vRip.emplace_back( R"( _/ \/ | \ | | \_ )" );
1116 vRip.emplace_back( R"( _/ \_ )" );
1117 vRip.emplace_back( R"(| |)" );
1118 iNameLine = vRip.size();
1119 vRip.emplace_back( R"( ) < )" );
1120 vRip.emplace_back( R"(| |)" );
1121 vRip.emplace_back( R"(| |)" );
1122 vRip.emplace_back( R"(| _ |)" );
1123 vRip.emplace_back( R"(|__/ |)" );
1124 iMaxWidth = utf8_width( vRip.back() );
1125 vRip.emplace_back( R"( / `--. |)" );
1126 vRip.emplace_back( R"(| ( )" );
1127 iInfoLine = vRip.size();
1128 vRip.emplace_back( R"(| |)" );
1129 vRip.emplace_back( R"(| |)" );
1130 vRip.emplace_back( R"(| % . |)" );
1131 vRip.emplace_back( R"(| @` %% |)" );
1132 vRip.emplace_back( R"(| %@%@%\ * %`%@%|)" );
1133 vRip.emplace_back( R"(%%@@@.%@%\%% `\ %%.%%@@%@)" );
1134 vRip.emplace_back( R"(@%@@%%%%%@@@@@@%%%%%%%%@@%%@@@%%%@%%@)" );
1135 }
1136
1137 const int iOffsetX = TERMX > FULL_SCREEN_WIDTH ? ( TERMX - FULL_SCREEN_WIDTH ) / 2 : 0;
1138 const int iOffsetY = TERMY > FULL_SCREEN_HEIGHT ? ( TERMY - FULL_SCREEN_HEIGHT ) / 2 : 0;
1139
1141 point( iOffsetX, iOffsetY ) );
1142 draw_border( w_rip );
1143
1144 sfx::do_player_death_hurt( g->u, true );
1149
1150 for( size_t iY = 0; iY < vRip.size(); ++iY ) {
1151 size_t iX = 0;
1152 const char *str = vRip[iY].data();
1153 for( int slen = vRip[iY].size(); slen > 0; ) {
1154 const uint32_t cTemp = UTF8_getch( &str, &slen );
1155 if( cTemp != U' ' ) {
1156 nc_color ncColor = c_light_gray;
1157
1158 if( cTemp == U'%' ) {
1159 ncColor = c_green;
1160
1161 } else if( cTemp == U'_' || cTemp == U'|' ) {
1162 ncColor = c_white;
1163
1164 } else if( cTemp == U'@' ) {
1165 ncColor = c_brown;
1166
1167 } else if( cTemp == U'*' ) {
1168 ncColor = c_red;
1169 }
1170
1171 mvwputch( w_rip, point( iX + FULL_SCREEN_WIDTH / 2 - ( iMaxWidth / 2 ), iY + 1 ), ncColor,
1172 cTemp );
1173 }
1174 iX += mk_wcwidth( cTemp );
1175 }
1176 }
1177
1178 std::string sTemp;
1179
1180 center_print( w_rip, iInfoLine++, c_white, _( "Survived:" ) );
1181
1183 const int minutes = to_minutes<int>( survived ) % 60;
1184 const int hours = to_hours<int>( survived ) % 24;
1185 const int days = to_days<int>( survived );
1186
1187 if( days > 0 ) {
1188 sTemp = string_format( "%dd %dh %dm", days, hours, minutes );
1189 } else if( hours > 0 ) {
1190 sTemp = string_format( "%dh %dm", hours, minutes );
1191 } else {
1192 sTemp = string_format( "%dm", minutes );
1193 }
1194
1195 center_print( w_rip, iInfoLine++, c_white, sTemp );
1196
1197 const int iTotalKills = get_kill_tracker().monster_kill_count();
1198
1199 sTemp = _( "Kills:" );
1200 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - 5, 1 + iInfoLine++ ), c_light_gray,
1201 ( sTemp + " " ) );
1202 wprintz( w_rip, c_magenta, "%d", iTotalKills );
1203
1204 sTemp = _( "In memory of:" );
1205 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ),
1207 sTemp );
1208
1209 sTemp = u.name;
1210 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ), c_white,
1211 sTemp );
1212
1213 sTemp = _( "Last Words:" );
1214 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ),
1216 sTemp );
1217
1218 int iStartX = FULL_SCREEN_WIDTH / 2 - ( ( iMaxWidth - 4 ) / 2 );
1219 std::string sLastWords = string_input_popup()
1220 .window( w_rip, point( iStartX, iNameLine ), iStartX + iMaxWidth - 4 - 1 )
1221 .max_length( iMaxWidth - 4 - 1 )
1222 .query_string();
1223 death_screen();
1224 const bool is_suicide = uquit == QUIT_SUICIDE;
1225 events().send<event_type::game_over>( is_suicide, sLastWords );
1226 // Struck the save_player_data here to forestall Weirdness
1227 std::string char_filename = generate_memorial_filename( u.name );
1228 move_save_to_graveyard( char_filename );
1229 write_memorial_file( char_filename, sLastWords );
1230 memorial().clear();
1231 std::vector<std::string> characters = list_active_characters();
1232 // remove current player from the active characters list, as they are dead
1233 std::vector<std::string>::iterator curchar = std::find( characters.begin(),
1234 characters.end(), u.name );
1235 if( curchar != characters.end() ) {
1236 characters.erase( curchar );
1237 }
1238
1239 if( characters.empty() ) {
1240 bool queryDelete = false;
1241 bool queryReset = false;
1242
1243 if( get_option<std::string>( "WORLD_END" ) == "query" ) {
1244 bool decided = false;
1245 std::string buffer = _( "Warning: NPC interactions and some other global flags "
1246 "will not all reset when starting a new character in an "
1247 "already-played world. This can lead to some strange "
1248 "behavior.\n\n"
1249 "Are you sure you wish to keep this world?"
1250 );
1251
1252 while( !decided ) {
1253 uilist smenu;
1254 smenu.allow_cancel = false;
1255 smenu.addentry( 0, true, 'r', "%s", _( "Reset world" ) );
1256 smenu.addentry( 1, true, 'd', "%s", _( "Delete world" ) );
1257 smenu.addentry( 2, true, 'k', "%s", _( "Keep world" ) );
1258 smenu.query();
1259
1260 switch( smenu.ret ) {
1261 case 0:
1262 queryReset = true;
1263 decided = true;
1264 break;
1265 case 1:
1266 queryDelete = true;
1267 decided = true;
1268 break;
1269 case 2:
1270 decided = query_yn( buffer );
1271 break;
1272 }
1273 }
1274 }
1275
1276 if( queryDelete || get_option<std::string>( "WORLD_END" ) == "delete" ) {
1277 world_generator->delete_world( world_generator->active_world->world_name, true );
1278
1279 } else if( queryReset || get_option<std::string>( "WORLD_END" ) == "reset" ) {
1280 world_generator->delete_world( world_generator->active_world->world_name, false );
1281 }
1282 } else if( get_option<std::string>( "WORLD_END" ) != "keep" ) {
1283 std::string tmpmessage;
1284 for( auto &character : characters ) {
1285 tmpmessage += "\n ";
1286 tmpmessage += character;
1287 }
1288 popup( _( "World retained. Characters remaining:%s" ), tmpmessage );
1289 }
1290 if( gamemode ) {
1291 gamemode = std::make_unique<special_game>(); // null gamemode or something..
1292 }
1293 }
1294
1295 //Reset any offset due to driving
1297
1298 //clear all sound channels
1304
1305 MAPBUFFER.reset();
1307
1308#if defined(__ANDROID__)
1309 quick_shortcuts_map.clear();
1310#endif
1311 return true;
1312}
uint32_t UTF8_getch(const char **src, int *srclen)
Definition: catacharset.cpp:18
int utf8_width(const char *s, const bool ignore_tags)
std::string name
Definition: character.h:1568
A wrapper over a pointer to a curses window.
Definition: cursesdef.h:55
void send(const cata::event &) const
Definition: event_bus.cpp:58
void move_save_to_graveyard(const std::string &dirname)
Definition: game.cpp:2775
bool save_maps()
Definition: game.cpp:3039
std::unique_ptr< special_game > gamemode
Definition: game.h:1103
void death_screen()
Definition: game.cpp:2725
monster_range all_monsters()
Same as all_creatures but iterators only over monsters.
Definition: game.cpp:12506
bool save_factions_missions_npcs()
Definition: game.cpp:3025
void despawn_monster(monster &critter)
Despawn a specific monster, it's stored on the overmap.
Definition: game.cpp:11531
const kill_tracker & get_kill_tracker() const
Definition: game.cpp:966
void write_memorial_file(const std::string &filename, std::string sLastWords)
Writes information about the character out to a text file timestamped with the time of the file was m...
Definition: game.cpp:3138
std::vector< std::string > list_active_characters()
Returns a list of currently active character saves.
Definition: game.cpp:3123
bool save_artifacts()
Definition: game.cpp:3033
memorial_logger & memorial()
Definition: game.cpp:3088
void reset_npc_dispositions()
Definition: game.cpp:2997
int monster_kill_count() const
string_input_popup & max_length(int value)
Maximal amount of Unicode characters that can be given by the user.
const std::string & query_string(bool loop=true, bool draw_only=false)
string_input_popup & window(const catacurses::window &w, const point &start, int endx)
Set the window area where to display the input text.
A duration defined as a number of specific time units.
Definition: calendar.h:180
bool allow_cancel
Definition: ui.h:362
bool has_amount(const itype_id &what, int qty, bool pseudo=true, const std::function< bool(const item &)> &filter=return_true< item >) const
Check instance provides at least qty of an item (.
Definition: visitable.cpp:1108
#define c_white
Definition: color.h:18
#define c_light_gray
Definition: color.h:19
#define c_green
Definition: color.h:22
#define c_magenta
Definition: color.h:25
#define c_brown
Definition: color.h:26
#define c_red
Definition: color.h:21
static const itype_id itype_holybook_bible1("holybook_bible1")
static std::string generate_memorial_filename(const std::string &char_name)
Definition: game.cpp:1001
static const itype_id itype_holybook_bible2("holybook_bible2")
static const itype_id itype_holybook_bible3("holybook_bible3")
@ QUIT_DIED
Definition: game.h:72
@ QUIT_SUICIDE
Definition: game.h:69
const time_point & start_of_cataclysm
Definition: calendar.cpp:33
window newwin(int nlines, int ncols, const point &begin)
Definition: ncurses_def.cpp:34
FMT_CONSTEXPR bool find(Ptr first, Ptr last, T value, Ptr &out)
const size_t size
Definition: om_direction.h:27
void do_player_death_hurt(const player &target, bool death)
Definition: sounds.cpp:1633
void fade_audio_channel(channel channel, int duration)
Definition: sounds.cpp:1618
void fade_audio_group(group group, int duration)
Definition: sounds.cpp:1617
int TERMX
Definition: output.cpp:47
void mvwprintz(const catacurses::window &w, const point &p, const nc_color &FG, const std::string &text)
Definition: output.cpp:2035
int FULL_SCREEN_HEIGHT
Definition: output.cpp:56
int TERMY
Definition: output.cpp:48
void center_print(const catacurses::window &w, const int y, const nc_color &FG, const std::string &text)
Definition: output.cpp:446
void wprintz(const catacurses::window &w, const nc_color &FG, const std::string &text)
Definition: output.cpp:2043
int FULL_SCREEN_WIDTH
Definition: output.cpp:55
void mvwputch(const catacurses::window &w, const point &p, nc_color FG, int ch)
Definition: output.cpp:477
void draw_border(const catacurses::window &w, nc_color border_color, const std::string &title, nc_color title_color)
Definition: output.cpp:575
int mk_wcwidth(uint32_t ucs)
Definition: wcwidth.cpp:94

References _, uilist::addentry(), all_monsters(), uilist::allow_cancel, sfx::any, c_brown, c_green, c_light_gray, c_magenta, c_red, c_white, center_print(), memorial_logger::clear(), overmapbuffer::clear(), sfx::context_themes, death_screen(), despawn_monster(), sfx::do_player_death_hurt(), draw_border(), events(), sfx::fade_audio_channel(), sfx::fade_audio_group(), sfx::fatigue, detail::find(), FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, g, game_over, gamemode, generate_memorial_filename(), get_kill_tracker(), visitable< T >::has_amount(), Character::has_trait(), itype_holybook_bible1, itype_holybook_bible2, itype_holybook_bible3, list_active_characters(), MAPBUFFER, string_input_popup::max_length(), memorial(), mk_wcwidth(), kill_tracker::monster_kill_count(), move_save_to_graveyard(), mvwprintz(), mvwputch(), Character::name, catacurses::newwin(), overmap_buffer, point_zero, popup(), uilist::query(), string_input_popup::query_string(), query_yn(), QUIT_DIED, QUIT_SUICIDE, mapbuffer::reset(), reset_npc_dispositions(), uilist::ret, save_artifacts(), save_factions_missions_npcs(), save_maps(), event_bus::send(), set_driving_view_offset(), om_direction::size, calendar::start_of_cataclysm, string_format(), TERMX, TERMY, sfx::time_of_day, calendar::turn, u, uquit, UTF8_getch(), utf8_width(), sfx::weather, string_input_popup::window(), world_generator, wprintz(), and write_memorial_file().

Referenced by do_turn().

◆ cleanup_dead()

void game::cleanup_dead ( )

Definition at line 4364 of file game.cpp.

4365{
4366 // Dead monsters need to stay in the tracker until everything else that needs to die does so
4367 // This is because dying monsters can still interact with other dying monsters (@ref Creature::killer)
4368 bool monster_is_dead = critter_tracker->kill_marked_for_death();
4369
4370 bool npc_is_dead = false;
4371 // can't use all_npcs as that does not include dead ones
4372 for( const auto &n : active_npc ) {
4373 if( n->is_dead() ) {
4374 n->die( nullptr ); // make sure this has been called to create corpses etc.
4375 npc_is_dead = true;
4376 }
4377 }
4378
4379 if( monster_is_dead ) {
4380 // From here on, pointers to creatures get invalidated as dead creatures get removed.
4381 critter_tracker->remove_dead();
4382 }
4383
4384 if( npc_is_dead ) {
4385 for( auto it = active_npc.begin(); it != active_npc.end(); ) {
4386 if( ( *it )->is_dead() ) {
4387 remove_npc_follower( ( *it )->getID() );
4388 overmap_buffer.remove_npc( ( *it )->getID() );
4389 it = active_npc.erase( it );
4390 } else {
4391 it++;
4392 }
4393 }
4394 }
4395
4396 critter_died = false;
4397}
void remove_npc_follower(const character_id &id)
Remove follower id from follower set.
Definition: game.cpp:1964
pimpl< Creature_tracker > critter_tracker
Definition: game.h:1021
std::list< shared_ptr_fast< npc > > active_npc
Definition: game.h:1085
bool critter_died
Has anything died in this turn and needs to be cleaned up?
Definition: game.h:1097
shared_ptr_fast< npc > remove_npc(const character_id &id)
Find npc by id and if found, erase it from the npc list and return it ( or return nullptr if not foun...

References active_npc, critter_died, critter_tracker, overmap_buffer, overmapbuffer::remove_npc(), and remove_npc_follower().

Referenced by do_turn(), and monmove().

◆ clear_zombies()

void game::clear_zombies ( )

Redirects to the creature_tracker clear() function.

Definition at line 5030 of file game.cpp.

5031{
5032 critter_tracker->clear();
5033}

References critter_tracker.

Referenced by setup().

◆ control_vehicle()

void game::control_vehicle ( )
private

Definition at line 5444 of file game.cpp.

5445{
5446 static const itype_id fuel_type_animal( "animal" );
5447 int veh_part = -1;
5448 vehicle *veh = remoteveh();
5449 if( veh == nullptr ) {
5450 if( const optional_vpart_position vp = m.veh_at( u.pos() ) ) {
5451 veh = &vp->vehicle();
5452 veh_part = vp->part_index();
5453 }
5454 }
5455 if( veh != nullptr && veh->player_in_control( u ) &&
5456 veh->avail_part_with_feature( veh_part, "CONTROLS", true ) >= 0 ) {
5457 veh->use_controls( u.pos() );
5458 } else if( veh && veh->player_in_control( u ) &&
5459 veh->avail_part_with_feature( veh_part, "CONTROL_ANIMAL", true ) >= 0 ) {
5460 u.controlling_vehicle = false;
5461 add_msg( m_info, _( "You let go of the reins." ) );
5462 } else if( veh && ( veh->avail_part_with_feature( veh_part, "CONTROLS", true ) >= 0 ||
5463 ( veh->avail_part_with_feature( veh_part, "CONTROL_ANIMAL", true ) >= 0 &&
5464 veh->has_engine_type( fuel_type_animal, false ) && veh->has_harnessed_animal() ) ) &&
5465 u.in_vehicle ) {
5466 if( u.has_trait( trait_WAYFARER ) ) {
5467 add_msg( m_info, _( "You refuse to take control of this vehicle." ) );
5468 return;
5469 }
5470 if( !veh->interact_vehicle_locked() ) {
5471 veh->handle_potential_theft( dynamic_cast<player &>( u ) );
5472 return;
5473 }
5474 if( veh->engine_on ) {
5475 if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
5476 return;
5477 }
5478 u.controlling_vehicle = true;
5479 add_msg( _( "You take control of the %s." ), veh->name );
5480 } else {
5481 if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
5482 return;
5483 }
5484 veh->start_engines( true );
5485 }
5486 } else { // Start looking for nearby vehicle controls.
5487 int num_valid_controls = 0;
5488 cata::optional<tripoint> vehicle_position;
5489 cata::optional<vpart_reference> vehicle_controls;
5490 for( const tripoint elem : m.points_in_radius( g->u.pos(), 1 ) ) {
5491 if( const optional_vpart_position vp = m.veh_at( elem ) ) {
5492 const cata::optional<vpart_reference> controls = vp.value().part_with_feature( "CONTROLS", true );
5493 if( controls ) {
5494 num_valid_controls++;
5495 vehicle_position = elem;
5496 vehicle_controls = controls;
5497 }
5498 }
5499 }
5500 if( num_valid_controls < 1 ) {
5501 add_msg( _( "No vehicle controls found." ) );
5502 return;
5503 } else if( num_valid_controls > 1 ) {
5504 vehicle_position = choose_adjacent( _( "Control vehicle where?" ) );
5505 if( !vehicle_position ) {
5506 return;
5507 }
5508 const optional_vpart_position vp = m.veh_at( *vehicle_position );
5509 if( vp ) {
5510 vehicle_controls = vp.value().part_with_feature( "CONTROLS", true );
5511 if( !vehicle_controls ) {
5512 add_msg( _( "The vehicle doesn't have controls there." ) );
5513 return;
5514 }
5515 } else {
5516 add_msg( _( "No vehicle there." ) );
5517 return;
5518 }
5519 }
5520 // If we hit neither of those, there's only one set of vehicle controls, which should already have been found.
5521 if( vehicle_controls ) {
5522 veh = &vehicle_controls->vehicle();
5523 if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
5524 return;
5525 }
5526 veh->use_controls( *vehicle_position );
5527 //May be folded up (destroyed), so need to re-get it
5528 veh = g->remoteveh();
5529 }
5530 }
5531 if( veh ) {
5532 // If we reached here, we gained control of a vehicle.
5533 // Clear the map memory for the area covered by the vehicle to eliminate ghost vehicles.
5534 for( const tripoint &target : veh->get_points() ) {
5535 u.clear_memorized_tile( m.getabs( target ) );
5536 }
5537 veh->is_following = false;
5538 veh->is_patrolling = false;
5539 veh->autopilot_on = false;
5540 veh->is_autodriving = false;
5541 }
5542}
cata::optional< tripoint > choose_adjacent(const std::string &message, const bool allow_vertical)
Request player input of adjacent tile, possibly including vertical tiles.
Definition: action.cpp:1013
bool in_vehicle
Definition: character.h:1575
void clear_memorized_tile(const tripoint &pos)
Definition: avatar.cpp:163
vehicle * remoteveh()
Returns the current remotely controlled vehicle.
Definition: game.cpp:2561
tripoint_range< tripoint > points_in_radius(const tripoint &center, size_t radius, size_t radiusz=0) const
Definition: map.cpp:8427
optional_vpart_position veh_at(const tripoint &p) const
Checks if tile is occupied by vehicle and by which part.
Definition: map.cpp:1003
Simple wrapper to forward functions that may return a cata::optional to vpart_position.
Definition: player.h:99
bool engine_on
Definition: vehicle.h:1970
std::set< tripoint > & get_points(bool force_refresh=false)
Definition: vehicle.cpp:6581
bool handle_potential_theft(player &p, bool check_only=false, bool prompt=true)
Definition: vehicle.cpp:4200
std::string name
Definition: vehicle.h:1830
bool has_engine_type(const itype_id &ft, bool enabled) const
Definition: vehicle.cpp:1031
void start_engines(bool take_control=false, bool autodrive=false)
void use_controls(const tripoint &pos)
Operate vehicle controls.
vehicle(const vproto_id &type_id, int init_veh_fuel=-1, int init_veh_status=-1)
Definition: vehicle.cpp:251
bool has_harnessed_animal() const
bool interact_vehicle_locked()
int avail_part_with_feature(int p, const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2545
bool autopilot_on
Definition: vehicle.h:1978
bool is_autodriving
Definition: vehicle.h:1963
cata::optional< vpart_reference > part_with_feature(const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2461
static const trait_id trait_WAYFARER("WAYFARER")

References _, add_msg(), vehicle::autopilot_on, vehicle::avail_part_with_feature(), choose_adjacent(), avatar::clear_memorized_tile(), Character::controlling_vehicle, vehicle::engine_on, fuel_type_animal, g, vehicle::get_points(), map::getabs(), vehicle::handle_potential_theft(), vehicle::has_engine_type(), vehicle::has_harnessed_animal(), Character::has_trait(), Character::in_vehicle, vehicle::interact_vehicle_locked(), vehicle::is_autodriving, vehicle::is_following, vehicle::is_patrolling, m, m_info, vehicle::name, vpart_position::part_with_feature(), vehicle::player_in_control(), map::points_in_radius(), Character::pos(), remoteveh(), vehicle::start_engines(), trait_WAYFARER, u, vehicle::use_controls(), cata::optional< T >::value(), map::veh_at(), and vehicle::vehicle().

Referenced by handle_action().

◆ create_or_get_main_ui_adaptor()

shared_ptr_fast< ui_adaptor > game::create_or_get_main_ui_adaptor ( )

In tiles mode w_terrain can have a different font (with a different tile dimension) or can be drawn by cata_tiles which uses tiles that again might have a different dimension then the normal font used everywhere else.

TERRAIN_WINDOW_WIDTH/TERRAIN_WINDOW_HEIGHT defines how many squares can be displayed in w_terrain (using it's specific tile dimension), not including partially drawn squares at the right/bottom. You should use it whenever you want to draw specific squares in that window or to determine whether a specific square is draw on screen (or outside the screen and needs scrolling).

TERRAIN_WINDOW_TERM_WIDTH/TERRAIN_WINDOW_TERM_HEIGHT defines the size of w_terrain in the standard font dimension (the font that everything else uses). You usually don't have to use it, expect for positioning of windows, because the window positions use the standard font dimension.

The code here calculates size available for w_terrain, caps it at max_view_size (the maximal view range than any character can have at any time). It is stored in TERRAIN_WINDOW_*.

Definition at line 3275 of file game.cpp.

3276{
3278 if( !ui ) {
3279 main_ui_adaptor = ui = make_shared_fast<ui_adaptor>();
3280 ui->on_redraw( []( const ui_adaptor & ) {
3281 g->draw();
3282 } );
3283 ui->on_screen_resize( [this]( ui_adaptor & ui ) {
3284 // remove some space for the sidebar, this is the maximal space
3285 // (using standard font) that the terrain window can have
3286 const int sidebar_left = panel_manager::get_manager().get_width_left();
3287 const int sidebar_right = panel_manager::get_manager().get_width_right();
3288
3290 TERRAIN_WINDOW_WIDTH = TERMX - ( sidebar_left + sidebar_right );
3293
3294 /**
3295 * In tiles mode w_terrain can have a different font (with a different
3296 * tile dimension) or can be drawn by cata_tiles which uses tiles that again
3297 * might have a different dimension then the normal font used everywhere else.
3298 *
3299 * TERRAIN_WINDOW_WIDTH/TERRAIN_WINDOW_HEIGHT defines how many squares can
3300 * be displayed in w_terrain (using it's specific tile dimension), not
3301 * including partially drawn squares at the right/bottom. You should
3302 * use it whenever you want to draw specific squares in that window or to
3303 * determine whether a specific square is draw on screen (or outside the screen
3304 * and needs scrolling).
3305 *
3306 * TERRAIN_WINDOW_TERM_WIDTH/TERRAIN_WINDOW_TERM_HEIGHT defines the size of
3307 * w_terrain in the standard font dimension (the font that everything else uses).
3308 * You usually don't have to use it, expect for positioning of windows,
3309 * because the window positions use the standard font dimension.
3310 *
3311 * The code here calculates size available for w_terrain, caps it at
3312 * max_view_size (the maximal view range than any character can have at
3313 * any time).
3314 * It is stored in TERRAIN_WINDOW_*.
3315 */
3317
3318 // Position of the player in the terrain window, it is always in the center
3321
3323 point( sidebar_left, 0 ) );
3324
3325 // minimap is always MINIMAP_WIDTH x MINIMAP_HEIGHT in size
3327
3328 // need to init in order to avoid crash. gets updated by the panel code.
3330
3331 ui.position_from_window( catacurses::stdscr );
3332 } );
3333 ui->mark_resize();
3334 }
3335 return ui;
3336}
catacurses::window w_pixel_minimap
Definition: game.h:1039
catacurses::window w_minimap_ptr
Definition: game.h:1076
weak_ptr_fast< ui_adaptor > main_ui_adaptor
Definition: game.h:1122
catacurses::window w_minimap
Definition: game.h:1038
catacurses::window w_terrain_ptr
Definition: game.h:1075
static panel_manager & get_manager()
Definition: panels.h:72
int get_width_right()
Definition: panels.cpp:2293
int get_width_left()
Definition: panels.cpp:2301
static constexpr int MINIMAP_WIDTH
static constexpr int MINIMAP_HEIGHT
void to_map_font_dimension(int &, int &)
Definition: game_ui.cpp:20
std::shared_ptr< T > shared_ptr_fast
Definition: memory_fast.h:16
window stdscr
int TERRAIN_WINDOW_TERM_WIDTH
Definition: output.cpp:53
int TERRAIN_WINDOW_TERM_HEIGHT
Definition: output.cpp:54
int POSX
Definition: output.cpp:49
int TERRAIN_WINDOW_WIDTH
Definition: output.cpp:51
int POSY
Definition: output.cpp:50
int TERRAIN_WINDOW_HEIGHT
Definition: output.cpp:52

References g, panel_manager::get_manager(), panel_manager::get_width_left(), panel_manager::get_width_right(), main_ui_adaptor, MINIMAP_HEIGHT, MINIMAP_WIDTH, catacurses::newwin(), point_zero, POSX, POSY, catacurses::stdscr, TERMX, TERMY, TERRAIN_WINDOW_HEIGHT, TERRAIN_WINDOW_TERM_HEIGHT, TERRAIN_WINDOW_TERM_WIDTH, TERRAIN_WINDOW_WIDTH, to_map_font_dimension(), w_minimap, w_minimap_ptr, w_pixel_minimap, w_terrain, and w_terrain_ptr.

◆ create_starting_npcs()

void game::create_starting_npcs ( )
private

Definition at line 971 of file game.cpp.

972{
973 if( !get_option<bool>( "STATIC_NPC" ) ||
974 get_option<std::string>( "STARTING_NPC" ) == "never" ) {
975 return; //Do not generate a starting npc.
976 }
977
978 //We don't want more than one starting npc per starting location
979 const int radius = 1;
980 if( !overmap_buffer.get_npcs_near_player( radius ).empty() ) {
981 return; //There is already an NPC in this starting location
982 }
983
984 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
985 tmp->normalize();
986 tmp->randomize( one_in( 2 ) ? NC_DOCTOR : NC_NONE );
987 tmp->spawn_at_precise( { get_levx(), get_levy() }, u.pos() - point_south_east );
989 tmp->form_opinion( u );
990 tmp->set_attitude( NPCATT_NULL );
991 //This sets the NPC mission. This NPC remains in the starting location.
992 tmp->mission = NPC_MISSION_SHELTER;
993 tmp->chatbin.first_topic = "TALK_SHELTER";
994 tmp->toggle_trait( trait_id( "NPC_STARTING_NPC" ) );
995 tmp->set_fac( faction_id( "no_faction" ) );
996 //One random starting NPC mission
997 tmp->add_new_mission( mission::reserve_random( ORIGIN_OPENER_NPC, tmp->global_omt_location(),
998 tmp->getID() ) );
999}
int get_levy() const
Definition: game.cpp:12396
int get_levx() const
The top left corner of the reality bubble (in submaps coordinates).
Definition: game.cpp:12391
static mission * reserve_random(mission_origin origin, const tripoint_abs_omt &p, const character_id &npc_id)
Definition: mission.cpp:200
std::vector< shared_ptr_fast< npc > > get_npcs_near_player(int radius)
Same as get_npcs_near(int,int,int,int) but uses player position as center.
void insert_npc(const shared_ptr_fast< npc > &who)
Adds the npc to an overmap ( based on the npcs current location ) and stores it there.
string_id< faction > faction_id
Definition: clzones.h:30
@ ORIGIN_OPENER_NPC
Definition: mission.h:45
@ NPCATT_NULL
Definition: npc.h:81
@ NPC_MISSION_SHELTER
Definition: npc.h:181
npc_class_id NC_NONE("NC_NONE")
npc_class_id NC_DOCTOR("NC_DOCTOR")
static constexpr point point_south_east
Definition: point.h:279
bool one_in(int chance)
Definition: rng.cpp:65

References get_levx(), get_levy(), overmapbuffer::get_npcs_near_player(), overmapbuffer::insert_npc(), NC_DOCTOR, NC_NONE, NPC_MISSION_SHELTER, NPCATT_NULL, one_in(), ORIGIN_OPENER_NPC, overmap_buffer, point_south_east, Character::pos(), mission::reserve_random(), trait_id, and u.

Referenced by start_game().

◆ critter_at() [1/2]

template<typename T >
T * game::critter_at ( const tripoint p,
bool  allow_hallucination = false 
)

Returns the Creature at the given location.

Optionally casted to the given type of creature: npc, player, monster - if there is a creature, but it's not of the requested type, returns nullptr.

Parameters
allow_hallucinationWhether to return monsters that are actually hallucinations.

Definition at line 4835 of file game.cpp.

4836{
4837 if( const shared_ptr_fast<monster> mon_ptr = critter_tracker->find( p ) ) {
4838 if( !allow_hallucination && mon_ptr->is_hallucination() ) {
4839 return nullptr;
4840 }
4841 // if we wanted to check for an NPC / player / avatar,
4842 // there is sometimes a monster AND an NPC/player there at the same time.
4843 // because the NPC/player etc may be riding that monster.
4844 // so only return the monster if we were actually looking for a monster.
4845 // otherwise, keep looking for the rider.
4846 // critter_at<creature> or critter_at() with no template will still default to returning monster first,
4847 // which is ok for the occasions where that happens.
4848 if( !mon_ptr->has_effect( effect_ridden ) || ( std::is_same<T, monster>::value ||
4849 std::is_same<T, Creature>::value || std::is_same<T, const monster>::value ||
4850 std::is_same<T, const Creature>::value ) ) {
4851 return dynamic_cast<T *>( mon_ptr.get() );
4852 }
4853 }
4854 if( !std::is_same<T, npc>::value && !std::is_same<T, const npc>::value ) {
4855 if( p == u.pos() ) {
4856 return dynamic_cast<T *>( &u );
4857 }
4858 }
4859 for( auto &cur_npc : active_npc ) {
4860 if( cur_npc->pos() == p && !cur_npc->is_dead() ) {
4861 return dynamic_cast<T *>( cur_npc.get() );
4862 }
4863 }
4864 return nullptr;
4865}
static const efftype_id effect_ridden("ridden")

References active_npc, critter_tracker, effect_ridden, Character::pos(), and u.

Referenced by draw_look_around_cursor(), examine(), find_or_make_stairs(), fling_creature(), forced_door_closing(), get_player_input(), is_empty(), knockback(), phasing_move(), print_all_tile_info(), spawn_hallucination(), swap_critters(), and update_stair_monsters().

◆ critter_at() [2/2]

template<typename T >
const T * game::critter_at ( const tripoint p,
bool  allow_hallucination = false 
) const

Definition at line 4868 of file game.cpp.

4869{
4870 return const_cast<game *>( this )->critter_at<T>( p, allow_hallucination );
4871}
Definition: game.h:144

◆ critter_by_id()

template<typename T >
template Creature * game::critter_by_id< Creature > ( const character_id id)
Returns
The living creature with the given id. Returns null if no living creature with such an id exists. Never returns a dead creature. Currently only the player character and npcs have ids.

Definition at line 4914 of file game.cpp.

4915{
4916 if( id == u.getID() ) {
4917 // player is always alive, therefore no is-dead check
4918 return dynamic_cast<T *>( &u );
4919 }
4920 return find_npc( id );
4921}
character_id getID() const
Definition: character.cpp:470
npc * find_npc(character_id id)
Find the npc with the given ID.
Definition: game.cpp:1953

References find_npc(), Character::getID(), and u.

◆ death_screen()

void game::death_screen ( )
private

Definition at line 2725 of file game.cpp.

2726{
2727 gamemode->game_over();
2731 follower_ids.clear();
2733}
stats_tracker & stats()
Definition: game.cpp:3083
void disp_NPC_epilogues()
Definition: game.cpp:3162
void display_faction_epilogues()
Definition: game.cpp:3179
void display_messages()
Definition: messages.cpp:801
void show_scores_ui(const achievements_tracker &achievements, stats_tracker &stats, const kill_tracker &kills)
Definition: scores_ui.cpp:69

References achievements_tracker_ptr, disp_NPC_epilogues(), display_faction_epilogues(), Messages::display_messages(), follower_ids, gamemode, get_kill_tracker(), show_scores_ui(), and stats().

Referenced by cleanup_at_end().

◆ despawn_monster()

void game::despawn_monster ( monster critter)

Despawn a specific monster, it's stored on the overmap.

Also removes it from the creature tracker. Keep in mind that any monster index may point to a different monster after calling this (or to no monster at all).

Definition at line 11531 of file game.cpp.

11532{
11533 if( !critter.is_hallucination() ) {
11534 // hallucinations aren't stored, they come and go as they like,
11536 }
11537
11538 critter.on_unload();
11539 remove_zombie( critter );
11540 // simulate it being dead so further processing of it (e.g. in monmove) will yield
11541 critter.set_hp( 0 );
11542}
void remove_zombie(const monster &critter)
Definition: game.cpp:5025
bool is_hallucination() const override
Definition: monster.cpp:2648
void on_unload()
Do some cleanup and caching as monster is being unloaded from map.
Definition: monster.cpp:2980
void set_hp(int hp)
Directly set the current hp of the monster (not capped at the maximal hp).
Definition: monster.cpp:1631
void despawn_monster(const monster &critter)
Despawn the monster back onto the overmap.

References overmapbuffer::despawn_monster(), monster::is_hallucination(), monster::on_unload(), overmap_buffer, remove_zombie(), and monster::set_hp().

Referenced by cleanup_at_end(), monmove(), place_player_overmap(), and shift_monsters().

◆ disable_robot()

bool game::disable_robot ( const tripoint p)

If there is a robot (that can be disabled), query the player and try to disable it.

Returns
true if the robot has been disabled or a similar action has been done. false if the player did not choose any action and the function has effectively done nothing.

Definition at line 9177 of file game.cpp.

9178{
9179 monster *const mon_ptr = critter_at<monster>( p );
9180 if( !mon_ptr ) {
9181 return false;
9182 }
9183 monster &critter = *mon_ptr;
9184 if( critter.friendly == 0 || critter.has_flag( MF_RIDEABLE_MECH ) ||
9185 ( critter.has_flag( MF_PAY_BOT ) && critter.has_effect( effect_paid ) ) ) {
9186 // Can only disable / reprogram friendly monsters
9187 return false;
9188 }
9189 const auto mid = critter.type->id;
9190 const auto mon_item_id = critter.type->revert_to_itype;
9191 if( !mon_item_id.is_empty() &&
9192 query_yn( _( "Deactivate the %s?" ), critter.name() ) ) {
9193
9194 u.moves -= 100;
9195 m.add_item_or_charges( p, critter.to_item() );
9196 if( !critter.has_flag( MF_INTERIOR_AMMO ) ) {
9197 for( auto &ammodef : critter.ammo ) {
9198 if( ammodef.second > 0 ) {
9199 m.spawn_item( p.xy(), ammodef.first, 1, ammodef.second, calendar::turn );
9200 }
9201 }
9202 }
9203 remove_zombie( critter );
9204 return true;
9205 }
9206 // Manhacks are special, they have their own menu here.
9207 if( mid == mon_manhack ) {
9208 int choice = UILIST_CANCEL;
9209 if( critter.has_effect( effect_docile ) ) {
9210 choice = uilist( _( "Reprogram the manhack?" ), { _( "Engage targets." ) } );
9211 } else {
9212 choice = uilist( _( "Reprogram the manhack?" ), { _( "Follow me." ) } );
9213 }
9214 switch( choice ) {
9215 case 0:
9216 if( critter.has_effect( effect_docile ) ) {
9217 critter.remove_effect( effect_docile );
9218 if( one_in( 3 ) ) {
9219 add_msg( _( "The %s hovers momentarily as it surveys the area." ),
9220 critter.name() );
9221 }
9222 } else {
9223 critter.add_effect( effect_docile, 1_turns, num_bp );
9224 if( one_in( 3 ) ) {
9225 add_msg( _( "The %s lets out a whirring noise and starts to follow you." ),
9226 critter.name() );
9227 }
9228 }
9229 u.moves -= 100;
9230 return true;
9231 default:
9232 break;
9233 }
9234 }
9235 return false;
9236}
@ num_bp
Definition: bodypart.h:52
bool remove_effect(const efftype_id &eff_id, body_part bp=num_bp)
Removes a listed effect.
Definition: creature.cpp:1133
void spawn_item(const tripoint &p, const itype_id &type_id, unsigned quantity=1, int charges=0, const time_point &birthday=calendar::start_of_cataclysm, int damlevel=0)
Definition: map.cpp:4172
bool has_flag(m_flag f) const override
Definition: monster.cpp:869
item to_item() const
Convert this monster into an item (see mtype::revert_to_itype).
Definition: monster.cpp:2788
void add_effect(const efftype_id &eff_id, const time_duration &dur, const bodypart_str_id &bp, int intensity=0, bool force=false, bool deferred=false) override
Performs any monster-specific modifications to the arguments before passing to Creature::add_effect()...
Definition: monster.cpp:1807
int friendly
Definition: monster.h:471
std::string name(unsigned int quantity=1) const
Definition: monster.cpp:492
std::map< itype_id, int > ammo
Definition: monster.h:512
static const efftype_id effect_docile("docile")
static const efftype_id effect_paid("paid")
static const mtype_id mon_manhack("mon_manhack")
@ MF_INTERIOR_AMMO
Definition: mtype.h:146
@ MF_RIDEABLE_MECH
Definition: mtype.h:115
@ MF_PAY_BOT
Definition: mtype.h:121
itype_id revert_to_itype
If this is not empty, the monster can be converted into an item of this type (if it's friendly).
Definition: mtype.h:361
constexpr point xy() const
Definition: point.h:220
const int UILIST_CANCEL
Definition: ui.h:28

References _, monster::add_effect(), map::add_item_or_charges(), add_msg(), monster::ammo, effect_docile, effect_paid, monster::friendly, Creature::has_effect(), monster::has_flag(), mtype::id, m, MF_INTERIOR_AMMO, MF_PAY_BOT, MF_RIDEABLE_MECH, mon_manhack, Creature::moves, monster::name(), num_bp, one_in(), query_yn(), Creature::remove_effect(), remove_zombie(), mtype::revert_to_itype, map::spawn_item(), monster::to_item(), calendar::turn, monster::type, u, UILIST_CANCEL, and tripoint::xy().

Referenced by examine().

◆ disp_NPC_epilogues()

void game::disp_NPC_epilogues ( )
private

Definition at line 3162 of file game.cpp.

3163{
3164 // TODO: This search needs to be expanded to all NPCs
3165 for( auto elem : follower_ids ) {
3167 if( !guy ) {
3168 continue;
3169 }
3170 const auto new_win = []() {
3172 point( std::max( 0, ( TERMX - FULL_SCREEN_WIDTH ) / 2 ),
3173 std::max( 0, ( TERMY - FULL_SCREEN_HEIGHT ) / 2 ) ) );
3174 };
3175 scrollable_text( new_win, guy->disp_name(), guy->get_epilogue() );
3176 }
3177}
shared_ptr_fast< npc > find_npc(character_id id)
Find the npc with the given ID.
void scrollable_text(const std::function< catacurses::window()> &init_window, const std::string &title, const std::string &text)
Definition: output.cpp:352

References overmapbuffer::find_npc(), follower_ids, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, catacurses::newwin(), overmap_buffer, scrollable_text(), TERMX, and TERMY.

Referenced by death_screen().

◆ disp_NPCs()

void game::disp_NPCs ( )

Definition at line 3213 of file game.cpp.

3214{
3215 const tripoint_abs_omt ppos = u.global_omt_location();
3216 const tripoint &lpos = u.pos();
3217 std::vector<shared_ptr_fast<npc>> npcs = overmap_buffer.get_npcs_near_player( 100 );
3218 std::sort( npcs.begin(), npcs.end(), npc_dist_to_player() );
3219
3221 ui_adaptor ui;
3222 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
3225 TERMY > FULL_SCREEN_HEIGHT ? ( TERMY - FULL_SCREEN_HEIGHT ) / 2 : 0 ) );
3226 ui.position_from_window( w );
3227 } );
3228 ui.mark_resize();
3229 ui.on_redraw( [&]( const ui_adaptor & ) {
3230 werase( w );
3231 mvwprintz( w, point_zero, c_white, _( "Your overmap position: %s" ), ppos.to_string() );
3232 // NOLINTNEXTLINE(cata-use-named-point-constants)
3233 mvwprintz( w, point( 0, 1 ), c_white, _( "Your local position: %s" ), lpos.to_string() );
3234 size_t i;
3235 for( i = 0; i < 20 && i < npcs.size(); i++ ) {
3236 const tripoint_abs_omt apos = npcs[i]->global_omt_location();
3237 mvwprintz( w, point( 0, i + 3 ), c_white, "%s: %s", npcs[i]->name,
3238 apos.to_string() );
3239 }
3240 for( const monster &m : all_monsters() ) {
3241 mvwprintz( w, point( 0, i + 3 ), c_white, "%s: %d, %d, %d", m.name(),
3242 m.posx(), m.posy(), m.posz() );
3243 ++i;
3244 }
3245 wnoutrefresh( w );
3246 } );
3247
3248 input_context ctxt( "DISP_NPCS" );
3249 ctxt.register_action( "CONFIRM" );
3250 ctxt.register_action( "QUIT" );
3251 ctxt.register_action( "HELP_KEYBINDINGS" );
3252 bool stop = false;
3253 while( !stop ) {
3255 const std::string action = ctxt.handle_input();
3256 if( action == "CONFIRM" || action == "QUIT" ) {
3257 stop = true;
3258 }
3259 }
3260}
tripoint_abs_omt global_omt_location() const
Returns the location of the player in global overmap terrain coordinates.
Definition: character.cpp:6328
std::string to_string() const
Definition: coordinates.h:140
Represents a context in which a set of actions can be performed.
Definition: input.h:382
std::string name(const tripoint &p)
Definition: map.cpp:1319
void wnoutrefresh(const window &win)
Definition: ncurses_def.cpp:43
void werase(const window &win)
Definition: ncurses_def.cpp:53
std::string to_string() const
Definition: point.cpp:16

References _, action, all_monsters(), c_white, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, overmapbuffer::get_npcs_near_player(), Character::global_omt_location(), input_context::handle_input(), m, mvwprintz(), map::name(), om_direction::name(), catacurses::newwin(), overmap_buffer, point_zero, Character::pos(), ui_manager::redraw(), input_context::register_action(), TERMX, TERMY, coords::coord_point< Point, Origin, Scale >::to_string(), tripoint::to_string(), u, catacurses::werase(), and catacurses::wnoutrefresh().

◆ display_faction_epilogues()

void game::display_faction_epilogues ( )
private

Definition at line 3179 of file game.cpp.

3180{
3181 for( const auto &elem : faction_manager_ptr->all() ) {
3182 if( elem.second.known_by_u ) {
3183 const std::vector<std::string> epilogue = elem.second.epilogue();
3184 if( !epilogue.empty() ) {
3185 const auto new_win = []() {
3187 point( std::max( 0, ( TERMX - FULL_SCREEN_WIDTH ) / 2 ),
3188 std::max( 0, ( TERMY - FULL_SCREEN_HEIGHT ) / 2 ) ) );
3189 };
3190 scrollable_text( new_win, elem.second.name,
3191 std::accumulate( epilogue.begin() + 1, epilogue.end(), epilogue.front(),
3192 []( const std::string & lhs, const std::string & rhs ) -> std::string {
3193 return lhs + "\n" + rhs;
3194 } ) );
3195 }
3196 }
3197 }
3198}
pimpl< faction_manager > faction_manager_ptr
Definition: game.h:1022

References faction_manager_ptr, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, catacurses::newwin(), scrollable_text(), TERMX, and TERMY.

Referenced by death_screen().

◆ display_lighting()

void game::display_lighting ( )
private

Definition at line 11743 of file game.cpp.

11744{
11745 if( use_tiles ) {
11747 if( !g->display_overlay_state( ACTION_DISPLAY_LIGHTING ) ) {
11748 return;
11749 }
11750 uilist lighting_menu;
11751 std::vector<std::string> lighting_menu_strings{
11752 "Global lighting conditions"
11753 };
11754
11755 int count = 0;
11756 for( const auto &menu_str : lighting_menu_strings ) {
11757 lighting_menu.addentry( count++, true, MENU_AUTOASSIGN, "%s", menu_str );
11758 }
11759
11760 lighting_menu.w_y_setup = 0;
11761 lighting_menu.query();
11762 if( ( lighting_menu.ret >= 0 ) &&
11763 ( static_cast<size_t>( lighting_menu.ret ) < lighting_menu_strings.size() ) ) {
11764 g->displaying_lighting_condition = lighting_menu.ret;
11765 }
11766 }
11767}
@ ACTION_DISPLAY_LIGHTING
Toggle lighting conditions map.
Definition: action.h:317
bool use_tiles
Use tiles for display.
void display_toggle_overlay(action_id)
Definition: game.cpp:11639
pos_scalar w_y_setup
Definition: ui.h:338
constexpr size_t count()
Definition: fmtlib_core.h:1073
const int MENU_AUTOASSIGN
Definition: ui.h:31

References ACTION_DISPLAY_LIGHTING, uilist::addentry(), detail::count(), display_toggle_overlay(), g, MENU_AUTOASSIGN, uilist::query(), uilist::ret, use_tiles, and uilist::w_y_setup.

Referenced by handle_action(), and look_around().

◆ display_overlay_state()

bool game::display_overlay_state ( action_id  action)

Definition at line 11634 of file game.cpp.

11635{
11637}
cata::optional< action_id > displaying_overlays
Definition: game.h:967

References action, and displaying_overlays.

Referenced by display_toggle_overlay(), and display_visibility().

◆ display_radiation()

void game::display_radiation ( )
private

Definition at line 11769 of file game.cpp.

11770{
11771 if( use_tiles ) {
11773 }
11774}
@ ACTION_DISPLAY_RADIATION
Toggle radiation map.
Definition: action.h:319

References ACTION_DISPLAY_RADIATION, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_scent()

void game::display_scent ( )
private

Definition at line 11648 of file game.cpp.

11649{
11650 if( use_tiles ) {
11652 } else {
11653 int div;
11654 bool got_value = query_int( div, _( "Set the Scent Map sensitivity to (0 to cancel)?" ) );
11655 if( !got_value || div < 1 ) {
11656 add_msg( _( "Never mind." ) );
11657 return;
11658 }
11659 shared_ptr_fast<game::draw_callback_t> scent_cb = make_shared_fast<game::draw_callback_t>( [&]() {
11660 scent.draw( w_terrain, div * 2, u.pos() + u.view_offset );
11661 } );
11662 g->add_draw_callback( scent_cb );
11663
11666 }
11667}
@ ACTION_DISPLAY_SCENT
Toggle scent map.
Definition: action.h:279
void wait_for_any_key()
Wait until the user presses a key.
Definition: input.cpp:1309
tripoint view_offset
Definition: player.h:681
void draw(const catacurses::window &win, int div, const tripoint &center) const
Definition: scent_map.cpp:70
input_manager inp_mngr
Definition: input.cpp:109
bool query_int(int &result, int default_val, const std::string &text)
Definition: output.cpp:718

References _, ACTION_DISPLAY_SCENT, add_msg(), display_toggle_overlay(), scent_map::draw(), g, inp_mngr, Character::pos(), query_int(), ui_manager::redraw(), scent, u, use_tiles, player::view_offset, w_terrain, and input_manager::wait_for_any_key().

Referenced by handle_action(), and look_around().

◆ display_temperature()

void game::display_temperature ( )
private

Definition at line 11669 of file game.cpp.

11670{
11671 if( use_tiles ) {
11673 }
11674}
@ ACTION_DISPLAY_TEMPERATURE
Toggle temperature map.
Definition: action.h:311

References ACTION_DISPLAY_TEMPERATURE, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_toggle_overlay()

void game::display_toggle_overlay ( action_id  action)

Definition at line 11639 of file game.cpp.

11640{
11641 if( display_overlay_state( action ) ) {
11642 displaying_overlays.reset();
11643 } else {
11645 }
11646}
bool display_overlay_state(action_id)
Definition: game.cpp:11634

References action, display_overlay_state(), and displaying_overlays.

Referenced by display_lighting(), display_radiation(), display_scent(), display_temperature(), display_transparency(), display_vehicle_ai(), and display_visibility().

◆ display_transparency()

void game::display_transparency ( )
private

Definition at line 11776 of file game.cpp.

11777{
11778 if( use_tiles ) {
11780 }
11781}
@ ACTION_DISPLAY_TRANSPARENCY
Toggle transparency map.
Definition: action.h:321

References ACTION_DISPLAY_TRANSPARENCY, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_vehicle_ai()

void game::display_vehicle_ai ( )
private

Definition at line 11676 of file game.cpp.

11677{
11678 if( use_tiles ) {
11680 }
11681}
@ ACTION_DISPLAY_VEHICLE_AI
Toggle vehicle autopilot data.
Definition: action.h:313

References ACTION_DISPLAY_VEHICLE_AI, display_toggle_overlay(), and use_tiles.

Referenced by handle_action().

◆ display_visibility()

void game::display_visibility ( )
private

Definition at line 11683 of file game.cpp.

11684{
11685 if( use_tiles ) {
11688 std::vector< tripoint > locations;
11689 uilist creature_menu;
11690 int num_creatures = 0;
11691 creature_menu.addentry( num_creatures++, true, MENU_AUTOASSIGN, "%s", _( "You" ) );
11692 locations.emplace_back( g->u.pos() ); // add player first.
11693 for( const Creature &critter : g->all_creatures() ) {
11694 if( critter.is_player() ) {
11695 continue;
11696 }
11697 creature_menu.addentry( num_creatures++, true, MENU_AUTOASSIGN, critter.disp_name() );
11698 locations.emplace_back( critter.pos() );
11699 }
11700
11701 pointmenu_cb callback( locations );
11702 creature_menu.callback = &callback;
11703 creature_menu.w_y_setup = 0;
11704 creature_menu.query();
11705 if( creature_menu.ret >= 0 && static_cast<size_t>( creature_menu.ret ) < locations.size() ) {
11706 Creature *creature = critter_at<Creature>( locations[creature_menu.ret] );
11708 }
11709 } else {
11711 }
11712 }
11713}
@ ACTION_DISPLAY_VISIBILITY
Toggle visibility map.
Definition: action.h:315
size_t num_creatures() const
Returns the approximate number of creatures in the reality bubble.
Definition: game.cpp:5015
Creature * displaying_visibility_creature
Creature for which to display the visibility map.
Definition: game.h:1058
Callback for uilist that pairs menu entries with points When an entry is selected,...
Definition: ui.h:423
uilist_callback * callback
Definition: ui.h:335
generic_factory< overmap_location > locations("overmap location")

References _, ACTION_DISPLAY_VISIBILITY, uilist::addentry(), uilist::callback, creature, display_overlay_state(), display_toggle_overlay(), displaying_visibility_creature, g, anonymous_namespace{overmap_location.cpp}::locations, MENU_AUTOASSIGN, num_creatures(), uilist::query(), uilist::ret, use_tiles, and uilist::w_y_setup.

Referenced by handle_action().

◆ do_turn()

bool game::do_turn ( )

MAIN GAME LOOP.

Returns true if game is over (death, saved, quit, etc.).

Definition at line 1434 of file game.cpp.

1435{
1436 if( is_game_over() ) {
1437 return cleanup_at_end();
1438 }
1439 // Actual stuff
1440 if( new_game ) {
1441 new_game = false;
1442 } else {
1443 gamemode->per_turn();
1444 calendar::turn += 1_turns;
1445 }
1446
1447 // starting a new turn, clear out temperature cache
1449 weather.clear_temp_cache();
1450
1451 if( npcs_dirty ) {
1452 load_npcs();
1453 }
1454
1457 // If controlling a vehicle that is owned by someone else
1459 vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
1460 if( veh && !veh->handle_potential_theft( dynamic_cast<player &>( u ), true ) ) {
1461 veh->handle_potential_theft( dynamic_cast<player &>( u ), false, false );
1462 }
1463 }
1464 // If riding a horse - chance to spook
1465 if( u.is_mounted() ) {
1467 }
1468 if( calendar::once_every( 1_days ) ) {
1470 }
1471
1472 // Move hordes every 2.5 min
1475 // Hordes that reached the reality bubble need to spawn,
1476 // make them spawn in invisible areas only.
1477 m.spawn_monsters( false );
1478 }
1479
1481
1482 u.update_body();
1483
1484 // Auto-save if autosave is enabled
1485 if( get_option<bool>( "AUTOSAVE" ) &&
1486 calendar::once_every( 1_turns * get_option<int>( "AUTOSAVE_TURNS" ) ) &&
1487 !u.is_dead_state() ) {
1488 autosave();
1489 }
1490
1491 weather.update_weather();
1493
1497 // Process NPC sound events before they move or they hear themselves talking
1498 for( npc &guy : all_npcs() ) {
1499 if( rl_dist( guy.pos(), u.pos() ) < MAX_VIEW_DISTANCE ) {
1501 }
1502 }
1503
1504 // Process sound events into sound markers for display to the player.
1506
1507 if( u.is_deaf() ) {
1509 }
1510
1511 if( !u.has_effect( effect_sleep ) || uquit == QUIT_WATCH ) {
1512 if( u.moves > 0 || uquit == QUIT_WATCH ) {
1513 while( u.moves > 0 || uquit == QUIT_WATCH ) {
1514 cleanup_dead();
1516 // Process any new sounds the player caused during their turn.
1517 for( npc &guy : all_npcs() ) {
1518 if( rl_dist( guy.pos(), u.pos() ) < MAX_VIEW_DISTANCE ) {
1520 }
1521 }
1524 wait_popup.reset();
1526 }
1527
1528 if( queue_screenshot ) {
1532 queue_screenshot = false;
1533 }
1534
1535 if( handle_action() ) {
1537 u.action_taken();
1538 }
1539
1540 if( is_game_over() ) {
1541 return cleanup_at_end();
1542 }
1543
1544 if( uquit == QUIT_WATCH ) {
1545 break;
1546 }
1547 if( u.activity ) {
1549 }
1550 }
1551 // Reset displayed sound markers now that the turn is over.
1552 // We only want this to happen if the player had a chance to examine the sounds.
1554 }
1555 }
1556
1557 if( driving_view_offset.x != 0 || driving_view_offset.y != 0 ) {
1558 // Still have a view offset, but might not be driving anymore,
1559 // or the option has been deactivated,
1560 // might also happen when someone dives from a moving car.
1561 // or when using the handbrake.
1562 vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
1563 calc_driving_offset( veh );
1564 }
1565
1566 // No-scent debug mutation has to be processed here or else it takes time to start working
1567 if( !u.has_active_bionic( bionic_id( "bio_scent_mask" ) ) &&
1568 !u.has_trait( trait_id( "DEBUG_NOSCENT" ) ) ) {
1571 }
1572 scent.update( u.pos(), m );
1573
1574 // We need floor cache before checking falling 'n stuff
1576
1579 m.vehmove();
1580 m.process_fields();
1581 m.process_items();
1584
1585 // Apply sounds from previous turn to monster and NPC AI.
1587 // Update vision caches for monsters. If this turns out to be expensive,
1588 // consider a stripped down cache just for monsters.
1589 m.build_map_cache( get_levz(), true );
1590 monmove();
1591 if( calendar::once_every( 5_minutes ) ) {
1593 }
1594 if( calendar::once_every( 10_seconds ) ) {
1595 for( const tripoint &elem : m.get_furn_field_locations() ) {
1596 const auto &furn = m.furn( elem ).obj();
1597 for( const emit_id &e : furn.emissions ) {
1598 m.emit_field( elem, e );
1599 }
1600 }
1601 }
1604 u.process_turn();
1605
1607 cleanup_dead();
1608
1609 if( u.moves < 0 && get_option<bool>( "FORCE_REDRAW" ) ) {
1612 }
1613
1614 if( get_levz() >= 0 && !u.is_underwater() ) {
1615 handle_weather_effects( weather.weather_id );
1616 }
1617
1618 const bool player_is_sleeping = u.has_effect( effect_sleep );
1619 bool wait_redraw = false;
1620 std::string wait_message;
1621 time_duration wait_refresh_rate;
1622 if( player_is_sleeping ) {
1623 wait_redraw = true;
1624 wait_message = _( "Wait till you wake up…" );
1625 wait_refresh_rate = 30_minutes;
1626 if( calendar::once_every( 1_hours ) ) {
1628 }
1629 } else if( u.has_destination() ) {
1630 wait_redraw = true;
1631 wait_message = _( "Travelling…" );
1632 wait_refresh_rate = 15_turns;
1633 } else if( const cata::optional<std::string> progress = u.activity.get_progress_message( u ) ) {
1634 wait_redraw = true;
1635 wait_message = *progress;
1636 if( u.activity.id() == ACT_AUTODRIVE ) {
1637 wait_refresh_rate = 1_turns;
1638 } else {
1639 wait_refresh_rate = 5_minutes;
1640 }
1641 }
1642 if( wait_redraw ) {
1644 calendar::once_every( std::min( 1_minutes, wait_refresh_rate ) ) ) {
1645 if( first_redraw_since_waiting_started || calendar::once_every( wait_refresh_rate ) ) {
1647 }
1648
1649 // Avoid redrawing the main UI every time due to invalidation
1651 wait_popup = std::make_unique<static_popup>();
1652 wait_popup->on_top( true ).wait_message( "%s", wait_message );
1656 }
1657 } else {
1658 // Nothing to wait for now
1659 wait_popup.reset();
1661 }
1662
1664 u.update_body_wetness( get_weather().get_precise() );
1665 u.apply_wetness_morale( weather.temperature );
1666
1667 if( calendar::once_every( 1_minutes ) ) {
1668 u.update_morale();
1669 }
1670
1671 if( calendar::once_every( 9_turns ) ) {
1673 }
1674
1675 if( !u.is_deaf() ) {
1677 }
1682
1683 // reset player noise
1684 u.volume = 0;
1685
1686 return false;
1687}
void update_morale()
Ticks down morale counters and removes them.
Definition: character.cpp:8991
void action_taken()
Called after every action, invalidates player caches.
Definition: character.cpp:870
bool check_mount_is_spooked()
Definition: character.cpp:1095
void update_bodytemp(const map &m, const weather_manager &weather)
Maintains body temperature.
Definition: character.cpp:5175
bool is_mounted() const
Definition: character.cpp:1136
bool has_destination() const
scenttype_id get_type_of_scent() const
Definition: character.cpp:8750
bool check_and_recover_morale()
Checks permanent morale for consistency and recovers it when an inconsistency is found.
Definition: character.cpp:9118
bool is_deaf() const
Definition: character.cpp:4479
void update_body()
Updates all "biology" by one turn.
Definition: character.cpp:4657
bool has_active_bionic(const bionic_id &b) const
Returns true if the player has the entered bionic id and it is powered on.
Definition: character.cpp:1883
void apply_wetness_morale(int temperature)
Recalculates morale penalty/bonus from wetness based on mutations, equipment and temperature.
Definition: suffer.cpp:1805
virtual bool is_underwater() const
Definition: creature.cpp:174
int get_levz() const
Definition: game.cpp:12401
void overmap_npc_move()
Definition: game.cpp:4524
class game::debug_hour_timer debug_hour_timer
npc_range all_npcs()
Same as all_creatures but iterators only over npcs.
Definition: game.cpp:12511
void monmove()
Definition: game.cpp:4399
void autopilot_vehicles()
process vehicles that are following the player
Definition: game.cpp:1751
void add_artifact_dreams()
Definition: game.cpp:12345
int moves_since_last_save
Definition: game.h:1088
bool take_screenshot() const
Saves a screenshot of the current viewport, as a PNG file.
Definition: game.cpp:7407
void calc_driving_offset(vehicle *veh=nullptr)
Definition: game.cpp:1332
bool cleanup_at_end()
Definition: game.cpp:1028
std::unique_ptr< static_popup > wait_popup
Definition: game.h:1124
bool queue_screenshot
Definition: game.h:1067
friend weather_manager & get_weather()
Definition: weather.cpp:64
void autosave()
Definition: game.cpp:11834
void process_activity()
Definition: game.cpp:1740
void update_stair_monsters()
Definition: game.cpp:11322
void process_voluntary_act_interrupt()
Definition: game.cpp:1701
void load_npcs()
Makes any nearby NPCs on the overmap active.
Definition: game.cpp:896
bool npcs_dirty
Has a NPC been spawned since last load?
Definition: game.h:1095
void cleanup_dead()
Definition: game.cpp:4364
bool is_game_over()
Definition: game.cpp:2678
void perhaps_add_random_npc()
Definition: game.cpp:11569
void mon_info_update()
Definition: game.cpp:4169
bool handle_action()
const T & obj() const
Definition: ammo_effect.cpp:26
void build_floor_caches()
Definition: map.cpp:7911
void process_falling()
Invoked drop_everything on cached dirty tiles.
Definition: map.cpp:2268
void emit_field(const tripoint &pos, const emit_id &src, float mul=1.0f)
Runs one cycle of emission src which may result in propagation of fields.
Definition: map_field.cpp:1925
const std::vector< tripoint > & get_furn_field_locations() const
Definition: map.cpp:7609
void spawn_monsters(bool ignore_sight)
Spawn monsters from submap spawn points and from the overmap.
Definition: map.cpp:7568
void vehmove()
Definition: map.cpp:409
void creature_in_field(Creature &critter)
Apply field effects to the creature when it's on a square with fields.
Definition: map_field.cpp:1560
void process_fields()
Definition: map_field.cpp:141
furn_id furn(const tripoint &p) const
Definition: map.cpp:1342
void build_map_cache(int zlev, bool skip_lightmap=false)
Definition: map.cpp:8039
void process_items()
Definition: map.cpp:4583
static void process_all()
Handles mission deadline processing.
Definition: mission.cpp:98
void set_scent(const tripoint_abs_omt &loc, int strength)
Method to set a scent trace.
void process_mongroups()
Process nearby monstergroups (dying mostly).
void move_hordes()
Let hordes move a step.
const activity_id & id() const
cata::optional< std::string > get_progress_message(const avatar &u) const
Helper that returns an activity specific progress message.
bool is_dead_state() const override
Returns true if the player should be dead.
Definition: player.cpp:924
int volume
Definition: player.h:684
int scent
Definition: player.h:694
void update_body_wetness(const w_point &weather)
Maintains body wetness and handles the rate at which the player dries.
Definition: player.cpp:1711
void process_turn() override
Resets movement points and applies other non-idempotent changes.
Definition: player.cpp:319
void set(const tripoint &p, int value, const scenttype_id &type=scenttype_id())
Get the scent value at the given position.
Definition: scent_map.cpp:102
void update(const tripoint &center, map &m)
Definition: scent_map.cpp:151
static constexpr time_duration from_minutes(const T m)
Definition: calendar.h:212
void process()
Process all queued events, potentially altering the game state and modifying the event queue.
static const activity_id ACT_AUTODRIVE("ACT_AUTODRIVE")
static const efftype_id effect_sleep("sleep")
@ QUIT_WATCH
Definition: game.h:73
static constexpr int MAX_VIEW_DISTANCE
void handle_weather_effects(const weather_type_id &w)
Definition: weather.cpp:522
bool once_every(const time_duration &event_frequency)
Predicate to handle rate-limiting.
Definition: calendar.cpp:490
explosion_queue & get_explosion_queue()
Definition: explosion.cpp:1159
void do_vehicle_engine_sfx()
Definition: sounds.cpp:1614
void do_hearing_loss(int turns=-1)
Definition: sounds.cpp:1609
void do_danger_music()
Definition: sounds.cpp:1613
void do_vehicle_exterior_engine_sfx()
Definition: sounds.cpp:1615
void do_fatigue()
Definition: sounds.cpp:1634
void remove_hearing_loss()
Definition: sounds.cpp:1610
void process_sound_markers(player *p)
Definition: sounds.cpp:386
void process_sounds()
Definition: sounds.cpp:304
void reset_markers()
Definition: sounds.cpp:572
vehicle * veh_pointer_or_null(const optional_vpart_position &p)

References _, ACT_AUTODRIVE, Character::action_taken(), Character::activity, add_artifact_dreams(), all_npcs(), Character::apply_wetness_morale(), autopilot_vehicles(), autosave(), map::build_floor_caches(), map::build_map_cache(), calc_driving_offset(), Character::check_and_recover_morale(), Character::check_mount_is_spooked(), cleanup_at_end(), cleanup_dead(), Character::controlling_vehicle, map::creature_in_field(), sfx::do_danger_music(), sfx::do_fatigue(), sfx::do_hearing_loss(), sfx::do_vehicle_engine_sfx(), sfx::do_vehicle_exterior_engine_sfx(), driving_view_offset, effect_sleep, map::emit_field(), explosion_handler::explosion_queue::execute(), first_redraw_since_waiting_started, time_duration::from_minutes(), map::furn(), gamemode, explosion_handler::get_explosion_queue(), map::get_furn_field_locations(), get_levz(), player_activity::get_progress_message(), Character::get_type_of_scent(), get_weather, Character::global_omt_location(), grid_tracker_ptr, handle_action(), vehicle::handle_potential_theft(), handle_weather_effects(), Character::has_active_bionic(), Character::has_destination(), Character::has_distant_destination(), Creature::has_effect(), Character::has_trait(), player_activity::id(), Character::in_vehicle, invalidate_main_ui_adaptor(), player::is_dead_state(), Character::is_deaf(), is_game_over(), Character::is_mounted(), Creature::is_underwater(), load_npcs(), m, MAX_VIEW_DISTANCE, mon_info_update(), monmove(), overmapbuffer::move_hordes(), Creature::moves, moves_since_last_save, new_game, npcs_dirty, int_id< T >::obj(), calendar::once_every(), overmap_buffer, overmap_npc_move(), perhaps_add_random_npc(), Character::pos(), game::debug_hour_timer::print_time(), timed_event_manager::process(), process_activity(), mission::process_all(), map::process_falling(), map::process_fields(), map::process_items(), overmapbuffer::process_mongroups(), sounds::process_sound_markers(), sounds::process_sounds(), player::process_turn(), process_voluntary_act_interrupt(), queue_screenshot, QUIT_WATCH, ui_manager::redraw(), refresh_display(), sfx::remove_hearing_loss(), reset_light_level(), sounds::reset_markers(), rl_dist(), scent, player::scent, scent_map::set(), overmapbuffer::set_scent(), map::spawn_monsters(), take_screenshot(), timed_events, calendar::turn, u, scent_map::update(), Character::update_body(), player::update_body_wetness(), Character::update_bodytemp(), Character::update_morale(), update_stair_monsters(), uquit, map::veh_at(), veh_pointer_or_null(), map::vehmove(), player::volume, wait_popup, point::x, and point::y.

◆ draw()

void game::draw ( )

Definition at line 3450 of file game.cpp.

3451{
3452 if( test_mode ) {
3453 return;
3454 }
3455
3456 //temporary fix for updating visibility for minimap
3457 ter_view_p.z = ( u.pos() + u.view_offset ).z;
3460
3461 werase( w_terrain );
3462 draw_ter();
3463 for( auto it = draw_callbacks.begin(); it != draw_callbacks.end(); ) {
3464 shared_ptr_fast<draw_callback_t> cb = it->lock();
3465 if( cb ) {
3466 ( *cb )();
3467 ++it;
3468 } else {
3469 it = draw_callbacks.erase( it );
3470 }
3471 }
3473
3474 draw_panels( true );
3475}
bool test_mode
Set to true when running in test mode (e.g.
tripoint ter_view_p
Definition: game.h:1034
void draw_panels(bool force_draw=false)
Definition: game.cpp:3477
void draw_ter(bool draw_sounds=true)
Definition: game.cpp:3591
void update_visibility_cache(int zlev)
Definition: map.cpp:5579
int z
Definition: point.h:152

References map::build_map_cache(), draw_callbacks, draw_panels(), draw_ter(), m, Character::pos(), ter_view_p, test_mode, u, map::update_visibility_cache(), player::view_offset, w_terrain, catacurses::werase(), catacurses::wnoutrefresh(), and tripoint::z.

◆ draw_below_override()

void game::draw_below_override ( const tripoint p,
bool  draw 
)

Definition at line 955 of file animation.cpp.

956{
957}

◆ draw_bullet()

void game::draw_bullet ( const tripoint t,
int  i,
const std::vector< tripoint > &  trajectory,
char  bullet 
)

Definition at line 510 of file animation.cpp.

512{
513 draw_bullet_curses( m, t, bullet, &trajectory[i] );
514}
void draw_bullet_curses(map &m, const tripoint &t, const char bullet, const tripoint *const p)
Definition: animation.cpp:451
std::vector< tripoint > trajectory
Definition: ranged.h:32

References anonymous_namespace{animation.cpp}::draw_bullet_curses(), and m.

◆ draw_critter()

void game::draw_critter ( const Creature critter,
const tripoint center 
)

Definition at line 3573 of file game.cpp.

3574{
3575 draw_critter_internal( w_terrain, critter, center, false, m, u );
3576}
static void draw_critter_internal(const catacurses::window &w, const Creature &critter, const tripoint &center, bool inverted, const map &m, const avatar &u)
Definition: game.cpp:3540

References center, draw_critter_internal(), m, u, and w_terrain.

Referenced by draw_ter().

◆ draw_critter_highlighted()

void game::draw_critter_highlighted ( const Creature critter,
const tripoint center 
)

Definition at line 3578 of file game.cpp.

3579{
3580 draw_critter_internal( w_terrain, critter, center, true, m, u );
3581}

References center, draw_critter_internal(), m, u, and w_terrain.

◆ draw_cursor()

void game::draw_cursor ( const tripoint p)

Definition at line 716 of file animation.cpp.

717{
718 const tripoint rp = relative_view_pos( *this, p );
719 mvwputch_inv( w_terrain, rp.xy(), c_light_green, 'X' );
720}
#define c_light_green
Definition: color.h:28
tripoint relative_view_pos(const game &g, const tripoint &p) noexcept
Definition: animation.cpp:119
void mvwputch_inv(const catacurses::window &w, const point &p, nc_color FG, int ch)
Definition: output.cpp:491

References c_light_green, mvwputch_inv(), anonymous_namespace{animation.cpp}::relative_view_pos(), w_terrain, and tripoint::xy().

Referenced by draw_look_around_cursor().

◆ draw_field_override()

void game::draw_field_override ( const tripoint p,
const field_type_id id 
)

Definition at line 911 of file animation.cpp.

912{
913}

◆ draw_furniture_override()

void game::draw_furniture_override ( const tripoint p,
const furn_id id 
)

Definition at line 872 of file animation.cpp.

873{
874}

◆ draw_graffiti_override()

void game::draw_graffiti_override ( const tripoint p,
bool  has 
)

Definition at line 885 of file animation.cpp.

886{
887}

◆ draw_highlight()

void game::draw_highlight ( const tripoint p)

Definition at line 729 of file animation.cpp.

730{
731 // Do nothing
732}

◆ draw_hit_mon()

void game::draw_hit_mon ( const tripoint p,
const monster m,
bool  dead = false 
)

Definition at line 573 of file animation.cpp.

574{
575 draw_hit_mon_curses( p, m, u, dead );
576}
void draw_hit_mon_curses(const tripoint &center, const monster &m, const player &u, const bool dead)
Definition: animation.cpp:544

References dead, anonymous_namespace{animation.cpp}::draw_hit_mon_curses(), m, and u.

◆ draw_hit_player()

void game::draw_hit_player ( const Character p,
int  dam 
)

Definition at line 618 of file animation.cpp.

619{
620 draw_hit_player_curses( *this, p, dam );
621}
void draw_hit_player_curses(const game &g, const Character &p, const int dam)
Definition: animation.cpp:581

References anonymous_namespace{animation.cpp}::draw_hit_player_curses().

◆ draw_item_override()

void game::draw_item_override ( const tripoint p,
const itype_id id,
const mtype_id mid,
bool  hilite 
)

Definition at line 925 of file animation.cpp.

927{
928}

◆ draw_line() [1/2]

void game::draw_line ( const tripoint p,
const std::vector< tripoint > &  points 
)

Definition at line 702 of file animation.cpp.

703{
704 draw_line_curses( *this, points );
705}
void draw_line_curses(game &g, const std::vector< tripoint > &points)
Definition: animation.cpp:682

References anonymous_namespace{animation.cpp}::draw_line_curses().

◆ draw_line() [2/2]

void game::draw_line ( const tripoint p,
const tripoint center_point,
const std::vector< tripoint > &  points,
bool  noreveal = false 
)

Definition at line 669 of file animation.cpp.

671{
672 if( !u.sees( p ) ) {
673 return;
674 }
675
676 draw_line_curses( *this, center, points, noreveal );
677}

References center, anonymous_namespace{animation.cpp}::draw_line_curses(), Character::sees(), and u.

Referenced by draw_ter().

◆ draw_look_around_cursor()

void game::draw_look_around_cursor ( const tripoint lp,
const visibility_variables cache 
)

Definition at line 5952 of file game.cpp.

5953{
5954 if( !liveview.is_enabled() ) {
5955#if defined( TILES )
5956 if( is_draw_tiles_mode() ) {
5957 draw_cursor( lp );
5958 return;
5959 }
5960#endif
5961 const tripoint view_center = u.pos() + u.view_offset;
5962 visibility_type visibility = VIS_HIDDEN;
5963 const bool inbounds = m.inbounds( lp );
5964 if( inbounds ) {
5965 visibility = m.get_visibility( m.apparent_light_at( lp, cache ), cache );
5966 }
5967 if( visibility == VIS_CLEAR ) {
5968 const Creature *const creature = critter_at( lp, true );
5969 if( creature != nullptr && u.sees( *creature ) ) {
5970 creature->draw( w_terrain, view_center, true );
5971 } else {
5972 m.drawsq( w_terrain, lp, drawsq_params().highlight( true ).center( view_center ) );
5973 }
5974 } else {
5975 std::string visibility_indicator;
5976 nc_color visibility_indicator_color = c_white;
5977 switch( visibility ) {
5978 case VIS_CLEAR:
5979 // Already handled by the outer if statement
5980 break;
5981 case VIS_BOOMER:
5982 case VIS_BOOMER_DARK:
5983 visibility_indicator = '#';
5984 visibility_indicator_color = c_pink;
5985 break;
5986 case VIS_DARK:
5987 visibility_indicator = '#';
5988 visibility_indicator_color = c_dark_gray;
5989 break;
5990 case VIS_LIT:
5991 visibility_indicator = '#';
5992 visibility_indicator_color = c_light_gray;
5993 break;
5994 case VIS_HIDDEN:
5995 visibility_indicator = 'x';
5996 visibility_indicator_color = c_white;
5997 break;
5998 }
5999
6000 const tripoint screen_pos = point( POSX, POSY ) + lp - view_center;
6001 mvwputch( w_terrain, screen_pos.xy(), visibility_indicator_color, visibility_indicator );
6002 }
6003 }
6004}
void draw_cursor(const tripoint &p)
Definition: animation.cpp:716
T * critter_at(const tripoint &p, bool allow_hallucination=false)
Returns the Creature at the given location.
Definition: game.cpp:4835
bool is_enabled()
Definition: live_view.cpp:75
virtual bool inbounds(const tripoint &p) const
Definition: map.cpp:7619
visibility_type get_visibility(lit_level ll, const visibility_variables &cache) const
Definition: map.cpp:5625
lit_level apparent_light_at(const tripoint &p, const visibility_variables &cache) const
Determine the visible light level for a tile, based on light_at for the tile, vision distance,...
Definition: lightmap.cpp:698
void drawsq(const catacurses::window &w, const tripoint &p, const drawsq_params &params) const
Draw the map tile at the given coordinate.
Definition: map.cpp:5803
#define c_dark_gray
Definition: color.h:20
#define c_pink
Definition: color.h:31
visibility_type
Definition: enums.h:57
@ VIS_CLEAR
Definition: enums.h:59
@ VIS_BOOMER
Definition: enums.h:61
@ VIS_DARK
Definition: enums.h:62
@ VIS_BOOMER_DARK
Definition: enums.h:63
@ VIS_HIDDEN
Definition: enums.h:58
@ VIS_LIT
Definition: enums.h:60
bool is_draw_tiles_mode()
Check whether we're in tile drawing mode.
Definition: output.cpp:2029
Draw parameters used by map::drawsq() and similar methods.
Definition: map.h:176

References map::apparent_light_at(), c_dark_gray, c_light_gray, c_pink, c_white, center, creature, critter_at(), draw_cursor(), map::drawsq(), map::get_visibility(), map::inbounds(), is_draw_tiles_mode(), live_view::is_enabled(), liveview, m, mvwputch(), Character::pos(), POSX, POSY, Character::sees(), u, player::view_offset, VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, VIS_LIT, w_terrain, and tripoint::xy().

Referenced by look_around().

◆ draw_minimap()

void game::draw_minimap ( )
private

Definition at line 3651 of file game.cpp.

3652{
3653
3654 // Draw the box
3655 werase( w_minimap );
3657
3658 const tripoint_abs_omt curs = u.global_omt_location();
3659 const point_abs_omt curs2( curs.xy() );
3661 bool drew_mission = targ == overmap::invalid_tripoint;
3662
3663 for( int i = -2; i <= 2; i++ ) {
3664 for( int j = -2; j <= 2; j++ ) {
3665 const point_abs_omt om( curs2 + point( i, j ) );
3666 nc_color ter_color;
3667 tripoint_abs_omt omp( om, get_levz() );
3668 std::string ter_sym;
3669 const bool seen = overmap_buffer.seen( omp );
3670 const bool vehicle_here = overmap_buffer.has_vehicle( omp );
3671 if( overmap_buffer.has_note( omp ) ) {
3672
3673 const std::string &note_text = overmap_buffer.note( omp );
3674
3675 ter_color = c_yellow;
3676 ter_sym = "N";
3677
3678 int symbolIndex = note_text.find( ':' );
3679 int colorIndex = note_text.find( ';' );
3680
3681 bool symbolFirst = symbolIndex < colorIndex;
3682
3683 if( colorIndex > -1 && symbolIndex > -1 ) {
3684 if( symbolFirst ) {
3685 if( colorIndex > 4 ) {
3686 colorIndex = -1;
3687 }
3688 if( symbolIndex > 1 ) {
3689 symbolIndex = -1;
3690 colorIndex = -1;
3691 }
3692 } else {
3693 if( symbolIndex > 4 ) {
3694 symbolIndex = -1;
3695 }
3696 if( colorIndex > 2 ) {
3697 colorIndex = -1;
3698 }
3699 }
3700 } else if( colorIndex > 2 ) {
3701 colorIndex = -1;
3702 } else if( symbolIndex > 1 ) {
3703 symbolIndex = -1;
3704 }
3705
3706 if( symbolIndex > -1 ) {
3707 int symbolStart = 0;
3708 if( colorIndex > -1 && !symbolFirst ) {
3709 symbolStart = colorIndex + 1;
3710 }
3711 ter_sym = note_text.substr( symbolStart, symbolIndex - symbolStart ).c_str()[0];
3712 }
3713
3714 if( colorIndex > -1 ) {
3715
3716 int colorStart = 0;
3717
3718 if( symbolIndex > -1 && symbolFirst ) {
3719 colorStart = symbolIndex + 1;
3720 }
3721
3722 std::string sym = note_text.substr( colorStart, colorIndex - colorStart );
3723
3724 if( sym.length() == 2 ) {
3725 if( sym == "br" ) {
3726 ter_color = c_brown;
3727 } else if( sym == "lg" ) {
3728 ter_color = c_light_gray;
3729 } else if( sym == "dg" ) {
3730 ter_color = c_dark_gray;
3731 }
3732 } else {
3733 char colorID = sym.c_str()[0];
3734 if( colorID == 'r' ) {
3735 ter_color = c_light_red;
3736 } else if( colorID == 'R' ) {
3737 ter_color = c_red;
3738 } else if( colorID == 'g' ) {
3739 ter_color = c_light_green;
3740 } else if( colorID == 'G' ) {
3741 ter_color = c_green;
3742 } else if( colorID == 'b' ) {
3743 ter_color = c_light_blue;
3744 } else if( colorID == 'B' ) {
3745 ter_color = c_blue;
3746 } else if( colorID == 'W' ) {
3747 ter_color = c_white;
3748 } else if( colorID == 'C' ) {
3749 ter_color = c_cyan;
3750 } else if( colorID == 'c' ) {
3751 ter_color = c_light_cyan;
3752 } else if( colorID == 'P' ) {
3753 ter_color = c_pink;
3754 } else if( colorID == 'm' ) {
3755 ter_color = c_magenta;
3756 }
3757 }
3758 }
3759 } else if( !seen ) {
3760 ter_sym = " ";
3761 ter_color = c_black;
3762 } else if( vehicle_here ) {
3763 ter_color = c_cyan;
3764 ter_sym = "c";
3765 } else {
3766 const oter_id &cur_ter = overmap_buffer.ter( omp );
3767 ter_sym = cur_ter->get_symbol();
3768 if( overmap_buffer.is_explored( omp ) ) {
3769 ter_color = c_dark_gray;
3770 } else {
3771 ter_color = cur_ter->get_color();
3772 }
3773 }
3774 if( !drew_mission && targ.xy() == omp.xy() ) {
3775 // If there is a mission target, and it's not on the same
3776 // overmap terrain as the player character, mark it.
3777 // TODO: Inform player if the mission is above or below
3778 drew_mission = true;
3779 if( i != 0 || j != 0 ) {
3780 ter_color = red_background( ter_color );
3781 }
3782 }
3783 if( i == 0 && j == 0 ) {
3784 mvwputch_hi( w_minimap, point( 3, 3 ), ter_color, ter_sym );
3785 } else {
3786 mvwputch( w_minimap, point( 3 + i, 3 + j ), ter_color, ter_sym );
3787 }
3788 }
3789 }
3790
3791 // Print arrow to mission if we have one!
3792 if( !drew_mission ) {
3793 double slope = curs2.x() != targ.x() ?
3794 static_cast<double>( targ.y() - curs2.y() ) / ( targ.x() - curs2.x() ) : 4;
3795
3796 if( curs2.x() == targ.x() || std::fabs( slope ) > 3.5 ) { // Vertical slope
3797 if( targ.y() > curs2.y() ) {
3798 mvwputch( w_minimap, point( 3, 6 ), c_red, "*" );
3799 } else {
3800 mvwputch( w_minimap, point( 3, 0 ), c_red, "*" );
3801 }
3802 } else {
3803 int arrowx = -1;
3804 int arrowy = -1;
3805 if( std::fabs( slope ) >= 1. ) { // y diff is bigger!
3806 arrowy = targ.y() > curs2.y() ? 6 : 0;
3807 arrowx =
3808 static_cast<int>( 3 + 3 * ( targ.y() > curs2.y() ? slope : ( 0 - slope ) ) );
3809 if( arrowx < 0 ) {
3810 arrowx = 0;
3811 }
3812 if( arrowx > 6 ) {
3813 arrowx = 6;
3814 }
3815 } else {
3816 arrowx = targ.x() > curs2.x() ? 6 : 0;
3817 arrowy = static_cast<int>( 3 + 3 * ( targ.x() > curs2.x() ? slope : -slope ) );
3818 if( arrowy < 0 ) {
3819 arrowy = 0;
3820 }
3821 if( arrowy > 6 ) {
3822 arrowy = 6;
3823 }
3824 }
3825 char glyph = '*';
3826 if( targ.z() > u.posz() ) {
3827 glyph = '^';
3828 } else if( targ.z() < u.posz() ) {
3829 glyph = 'v';
3830 }
3831
3832 mvwputch( w_minimap, point( arrowx, arrowy ), c_red, glyph );
3833 }
3834 }
3835
3836 const int sight_points = g->u.overmap_sight_range( g->light_level( g->u.posz() ) );
3837 for( int i = -3; i <= 3; i++ ) {
3838 for( int j = -3; j <= 3; j++ ) {
3839 if( i > -3 && i < 3 && j > -3 && j < 3 ) {
3840 continue; // only do hordes on the border, skip inner map
3841 }
3842 const tripoint_abs_omt omp( curs2 + point( i, j ), get_levz() );
3844 if( overmap_buffer.seen( omp )
3845 && g->u.overmap_los( omp, sight_points ) ) {
3846 mvwputch( w_minimap, point( i + 3, j + 3 ), c_green,
3847 overmap_buffer.get_horde_size( omp ) > HORDE_VISIBILITY_SIZE * 2 ? 'Z' : 'z' );
3848 }
3849 }
3850 }
3851 }
3852
3854}
tripoint_abs_omt get_active_mission_target() const
Returns the target of the active mission or overmap::invalid_tripoint if there is no active mission.
Definition: avatar.cpp:196
constexpr auto & x()
Definition: coordinates.h:118
constexpr auto & z()
Definition: coordinates.h:133
constexpr auto & y()
Definition: coordinates.h:124
constexpr auto xy() const
Definition: coordinates.h:130
static constexpr tripoint_abs_omt invalid_tripoint
Dummy value, used to indicate that a point returned by a function is invalid.
Definition: overmap.h:260
bool seen(const tripoint_abs_omt &p)
const std::string & note(const tripoint_abs_omt &p)
int get_horde_size(const tripoint_abs_omt &p)
bool is_explored(const tripoint_abs_omt &p)
const oter_id & ter(const tripoint_abs_omt &p)
Returns the overmap terrain at the given OMT coordinates.
bool has_note(const tripoint_abs_omt &p)
Uses global overmap terrain coordinates.
bool has_vehicle(const tripoint_abs_omt &p)
nc_color red_background(const nc_color &c)
Definition: color.cpp:515
#define c_blue
Definition: color.h:23
#define c_black
Definition: color.h:17
#define c_light_blue
Definition: color.h:29
#define c_yellow
Definition: color.h:32
#define c_light_cyan
Definition: color.h:30
#define c_cyan
Definition: color.h:24
#define c_light_red
Definition: color.h:27
static constexpr int HORDE_VISIBILITY_SIZE
constexpr scale om
Definition: coordinates.h:34
void mvwputch_hi(const catacurses::window &w, const point &p, nc_color FG, int ch)
Definition: output.cpp:508
std::string get_symbol(const bool from_land_use_code=false) const
Definition: omdata.h:213
nc_color get_color(const bool from_land_use_code=false) const
Definition: omdata.h:221

References c_black, c_blue, c_brown, c_cyan, c_dark_gray, c_green, c_light_blue, c_light_cyan, c_light_gray, c_light_green, c_light_red, c_magenta, c_pink, c_red, c_white, c_yellow, draw_border(), units::fabs(), g, avatar::get_active_mission_target(), oter_t::get_color(), overmapbuffer::get_horde_size(), get_levz(), oter_t::get_symbol(), Character::global_omt_location(), overmapbuffer::has_note(), overmapbuffer::has_vehicle(), HORDE_VISIBILITY_SIZE, overmap::invalid_tripoint, overmapbuffer::is_explored(), mvwputch(), mvwputch_hi(), overmapbuffer::note(), coords::om, overmap_buffer, Character::posz(), red_background(), overmapbuffer::seen(), overmapbuffer::ter(), u, w_minimap, catacurses::werase(), catacurses::wnoutrefresh(), coords::coord_point< Point, Origin, Scale >::x(), coords::coord_point< Point, Origin, Scale >::xy(), coords::coord_point< Point, Origin, Scale >::y(), and coords::coord_point< Point, Origin, Scale >::z().

◆ draw_monster_override()

void game::draw_monster_override ( const tripoint p,
const mtype_id id,
int  count,
bool  more,
Creature::Attitude  att 
)

Definition at line 969 of file animation.cpp.

971{
972}

◆ draw_panels()

void game::draw_panels ( bool  force_draw = false)

Definition at line 3477 of file game.cpp.

3478{
3479 static int previous_turn = -1;
3480 const int current_turn = to_turns<int>( calendar::turn - calendar::turn_zero );
3481 const bool draw_this_turn = current_turn > previous_turn || force_draw;
3482 auto &mgr = panel_manager::get_manager();
3483 int y = 0;
3484 const bool sidebar_right = get_option<std::string>( "SIDEBAR_POSITION" ) == "right";
3485 int spacer = get_option<bool>( "SIDEBAR_SPACERS" ) ? 1 : 0;
3486 int log_height = 0;
3487 for( const window_panel &panel : mgr.get_current_layout() ) {
3488 if( panel.get_height() != -2 && panel.toggle && panel.render() ) {
3489 log_height += panel.get_height() + spacer;
3490 }
3491 }
3492 log_height = std::max( TERMY - log_height, 3 );
3493 for( const window_panel &panel : mgr.get_current_layout() ) {
3494 if( panel.render() ) {
3495 // height clamped to window height.
3496 int h = std::min( panel.get_height(), TERMY - y );
3497 if( h == -2 ) {
3498 h = log_height;
3499 }
3500 h += spacer;
3501 if( panel.toggle && panel.render() && h > 0 ) {
3502 if( panel.always_draw || draw_this_turn ) {
3503 panel.draw( u, catacurses::newwin( h, panel.get_width(),
3504 point( sidebar_right ? TERMX - panel.get_width() : 0, y ) ) );
3505 }
3506 if( show_panel_adm ) {
3507 const std::string panel_name = _( panel.get_name() );
3508 const int panel_name_width = utf8_width( panel_name );
3509 auto label = catacurses::newwin( 1, panel_name_width, point( sidebar_right ?
3510 TERMX - panel.get_width() - panel_name_width - 1 : panel.get_width() + 1, y ) );
3511 werase( label );
3512 mvwprintz( label, point_zero, c_light_red, panel_name );
3514 label = catacurses::newwin( h, 1,
3515 point( sidebar_right ? TERMX - panel.get_width() - 1 : panel.get_width(), y ) );
3516 werase( label );
3517 if( h == 1 ) {
3519 } else {
3521 for( int i = 1; i < h - 1; i++ ) {
3523 }
3524 mvwputch( label, point( 0, h - 1 ), c_light_red, sidebar_right ? LINE_XXOO : LINE_XOOX );
3525 }
3527 }
3528 y += h;
3529 }
3530 }
3531 }
3532 previous_turn = current_turn;
3533}
bool show_panel_adm
Definition: game.h:1062
const time_point turn_zero
Represents time point 0.
Definition: calendar.cpp:26
#define LINE_XOXO
Definition: output.h:39
#define LINE_OXOX
Definition: output.h:40
#define LINE_OXXX
Definition: output.h:48
#define LINE_XOOX
Definition: output.h:44
#define LINE_XXOO
Definition: output.h:41
Struct used for storing labels (easier to json opposed to a std::map<point, std::string>)
Definition: vehicle.h:578

References _, c_light_red, panel_manager::get_manager(), LINE_OXOX, LINE_OXXX, LINE_XOOX, LINE_XOXO, LINE_XXOO, mvwprintz(), mvwputch(), catacurses::newwin(), point_zero, show_panel_adm, TERMX, TERMY, calendar::turn, calendar::turn_zero, u, utf8_width(), catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by draw().

◆ draw_pixel_minimap()

void game::draw_pixel_minimap ( const catacurses::window w)

Definition at line 3535 of file game.cpp.

3536{
3537 w_pixel_minimap = w;
3538}

References w_pixel_minimap.

◆ draw_radiation_override()

void game::draw_radiation_override ( const tripoint p,
int  rad 
)

Definition at line 846 of file animation.cpp.

847{
848}

◆ draw_sct()

void game::draw_sct ( )

Definition at line 797 of file animation.cpp.

798{
799 draw_sct_curses( *this );
800}
void draw_sct_curses(const game &g)
Definition: animation.cpp:764

References anonymous_namespace{animation.cpp}::draw_sct_curses().

Referenced by get_player_input().

◆ draw_ter() [1/2]

void game::draw_ter ( bool  draw_sounds = true)

Definition at line 3591 of file game.cpp.

3592{
3594 draw_sounds );
3595}
bool is_looking
Definition: game.h:250

References draw_ter(), is_looking, Character::pos(), u, and player::view_offset.

Referenced by draw(), and draw_ter().

◆ draw_ter() [2/2]

void game::draw_ter ( const tripoint center,
bool  looking = false,
bool  draw_sounds = true 
)

Definition at line 3597 of file game.cpp.

3598{
3600
3601 m.draw( w_terrain, center );
3602
3603 if( draw_sounds ) {
3605 }
3606
3607 for( Creature &critter : all_creatures() ) {
3608 draw_critter( critter, center );
3609 }
3610
3611 if( !destination_preview.empty() && u.view_offset.z == 0 ) {
3612 // Draw auto-move preview trail
3613 const tripoint &final_destination = destination_preview.back();
3614 tripoint line_center = u.pos() + u.view_offset;
3615 draw_line( final_destination, line_center, destination_preview, true );
3616 mvwputch( w_terrain, final_destination.xy() - u.view_offset.xy() + point( POSX - u.posx(),
3617 POSY - u.posy() ), c_white, 'X' );
3618 }
3619
3620 if( u.controlling_vehicle && !looking ) {
3621 draw_veh_dir_indicator( false );
3622 draw_veh_dir_indicator( true );
3623 }
3624 // Place the cursor over the player as is expected by screen readers.
3625 wmove( w_terrain, -center.xy() + g->u.pos().xy() + point( POSX, POSY ) );
3626}
int posx() const override
Definition: character.h:838
int posy() const override
Definition: character.h:841
void draw_critter(const Creature &critter, const tripoint &center)
Definition: game.cpp:3573
Creature_range all_creatures()
Returns an anonymous range that contains all creatures.
Definition: game.cpp:12501
std::vector< tripoint > destination_preview
Definition: game.h:1114
void draw_veh_dir_indicator(bool next)
Definition: game.cpp:3643
void draw_line(const tripoint &p, const tripoint &center_point, const std::vector< tripoint > &points, bool noreveal=false)
Definition: animation.cpp:669
void draw(const catacurses::window &w, const tripoint &center)
Draw a visible part of the map into w.
Definition: map.cpp:5675
static void draw_footsteps(const catacurses::window &window, const tripoint &offset)
Definition: game.cpp:3263
void wmove(const window &win, const point &p)
Definition: ncurses_def.cpp:98

References all_creatures(), c_white, center, Character::controlling_vehicle, destination_preview, map::draw(), draw_critter(), draw_footsteps(), draw_line(), draw_veh_dir_indicator(), g, m, mvwputch(), Character::pos(), Character::posx(), POSX, Character::posy(), POSY, ter_view_p, u, player::view_offset, w_terrain, catacurses::wmove(), tripoint::xy(), and tripoint::z.

◆ draw_terrain_override()

void game::draw_terrain_override ( const tripoint p,
const ter_id id 
)

Definition at line 859 of file animation.cpp.

860{
861}

◆ draw_trail_to_square()

void game::draw_trail_to_square ( const tripoint t,
bool  bDrawX 
)

Definition at line 7255 of file game.cpp.

7256{
7257 ::draw_trail( u.pos(), u.pos() + t, bDrawX );
7258}
static void draw_trail(const tripoint &start, const tripoint &end, bool bDrawX)
Definition: game.cpp:7225

References draw_trail(), Character::pos(), and u.

◆ draw_trap_override()

void game::draw_trap_override ( const tripoint p,
const trap_id id 
)

Definition at line 898 of file animation.cpp.

899{
900}

◆ draw_veh_dir_indicator()

void game::draw_veh_dir_indicator ( bool  next)

Definition at line 3643 of file game.cpp.

3644{
3645 if( const cata::optional<tripoint> indicator_offset = get_veh_dir_indicator_location( next ) ) {
3646 auto col = next ? c_white : c_dark_gray;
3647 mvwputch( w_terrain, indicator_offset->xy() - u.view_offset.xy() + point( POSX, POSY ), col, 'X' );
3648 }
3649}
cata::optional< tripoint > get_veh_dir_indicator_location(bool next) const
Returns the location where the indicator should go relative to the reality bubble,...
Definition: game.cpp:3628

References c_dark_gray, c_white, get_veh_dir_indicator_location(), mvwputch(), POSX, POSY, u, player::view_offset, w_terrain, and tripoint::xy().

Referenced by draw_ter().

◆ draw_vpart_override()

void game::draw_vpart_override ( const tripoint p,
const vpart_id id,
int  part_mod,
units::angle  veh_dir,
bool  hilite,
const point mount 
)

Definition at line 941 of file animation.cpp.

943{
944}

◆ draw_weather()

void game::draw_weather ( const weather_printable wPrint)

Definition at line 756 of file animation.cpp.

757{
759}
void draw_weather_curses(const catacurses::window &win, const weather_printable &w)
Definition: animation.cpp:737

References anonymous_namespace{animation.cpp}::draw_weather_curses(), and w_terrain.

Referenced by get_player_input().

◆ draw_zones()

void game::draw_zones ( const tripoint start,
const tripoint end,
const tripoint offset 
)

Definition at line 832 of file animation.cpp.

833{
834 draw_zones_curses( w_terrain, start, end, offset );
835}
void draw_zones_curses(const catacurses::window &w, const tripoint &start, const tripoint &end, const tripoint &offset)
Definition: animation.cpp:805

References anonymous_namespace{animation.cpp}::draw_zones_curses(), and w_terrain.

◆ drop()

void game::drop ( )
private

Definition at line 8297 of file game.cpp.

8298{
8300}
void drop(item_location loc, const tripoint &where)
Drops an item to the specified location.
Definition: character.cpp:2501
drop_locations multidrop(player &p)
Select items to drop.

References Character::drop(), game_menus::inv::multidrop(), Character::pos(), and u.

Referenced by handle_action().

◆ drop_in_direction()

void game::drop_in_direction ( )
private

Definition at line 8302 of file game.cpp.

8303{
8304 if( const cata::optional<tripoint> pnt = choose_adjacent( _( "Drop where?" ) ) ) {
8305 u.drop( game_menus::inv::multidrop( u ), *pnt );
8306 }
8307}

References _, choose_adjacent(), Character::drop(), game_menus::inv::multidrop(), and u.

Referenced by handle_action().

◆ dump_stats()

bool game::dump_stats ( const std::string &  what,
dump_mode  mode,
const std::vector< std::string > &  opts 
)

write statistics to stdout and

Returns
true if successful

Definition at line 37 of file dump.cpp.

39{
40 try {
41 loading_ui ui( false );
43 load_packs( _( "Loading content packs" ), { mod_id( "dda" ) }, ui );
45 } catch( const std::exception &err ) {
46 std::cerr << "Error loading data from json: " << err.what() << std::endl;
47 return false;
48 }
49
50 std::vector<std::string> header;
51 std::vector<std::vector<std::string>> rows;
52
53 int scol = 0; // sorting column
54
55 std::map<std::string, standard_npc> test_npcs;
56 test_npcs[ "S1" ] = standard_npc( "S1", { 0, 0, 2 }, { "gloves_survivor", "mask_lsurvivor" },
57 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
58 test_npcs[ "S2" ] = standard_npc( "S2", { 0, 0, 3 }, { "gloves_fingerless", "sunglasses" },
59 4, 8, 8, 8, 10 /* PER 10 */ );
60 test_npcs[ "S3" ] = standard_npc( "S3", { 0, 0, 4 }, { "gloves_plate", "helmet_plate" },
61 4, 10, 8, 8, 8 /* STAT 10 */ );
62 test_npcs[ "S4" ] = standard_npc( "S4", { 0, 0, 5 }, {}, 0, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
63 test_npcs[ "S5" ] = standard_npc( "S5", { 0, 0, 6 }, {}, 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
64 test_npcs[ "S6" ] = standard_npc( "S6", { 0, 0, 7 }, { "gloves_hsurvivor", "mask_hsurvivor" },
65 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
66
67 std::map<std::string, item> test_items;
68 test_items[ "G1" ] = item( "glock_19" ).ammo_set( itype_id( "9mm" ) );
69 test_items[ "G2" ] = item( "hk_mp5" ).ammo_set( itype_id( "9mm" ) );
70 test_items[ "G3" ] = item( "ar15" ).ammo_set( itype_id( "223" ) );
71 test_items[ "G4" ] = item( "remington_700" ).ammo_set( itype_id( "270" ) );
72 test_items[ "G4" ].put_in( item( "rifle_scope" ) );
73
74 if( what == "AMMO" ) {
75 header = {
76 "Name", "Ammo", "Volume", "Weight", "Stack",
77 "Range", "Dispersion", "Recoil", "Damage", "Pierce", "Damage multiplier"
78 };
79 auto dump = [&rows]( const item & obj ) {
80 std::vector<std::string> r;
81 r.push_back( obj.tname( 1, false ) );
82 r.push_back( obj.ammo_type().str() );
83 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
84 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
85 r.push_back( std::to_string( obj.type->stack_size ) );
86 r.push_back( std::to_string( obj.type->ammo->range ) );
87 r.push_back( std::to_string( obj.type->ammo->dispersion ) );
88 r.push_back( std::to_string( obj.type->ammo->recoil ) );
89 damage_instance damage = obj.type->ammo->damage;
90 r.push_back( std::to_string( damage.total_damage() ) );
91 r.push_back( std::to_string( damage.empty() ? 0 : ( *damage.begin() ).res_pen ) );
92 rows.push_back( r );
93 };
94 for( const itype *e : item_controller->all() ) {
95 if( e->ammo ) {
96 dump( item( e, calendar::turn, item::solitary_tag {} ) );
97 }
98 }
99
100 } else if( what == "ARMOR" ) {
101 header = {
102 "Name", "Encumber (fit)", "Warmth", "Weight", "Storage", "Coverage", "Bash", "Cut", "Bullet", "Acid", "Fire"
103 };
104 auto dump = [&rows]( const item & obj ) {
105 std::vector<std::string> r;
106 r.push_back( obj.tname( 1, false ) );
107 r.push_back( std::to_string( obj.get_encumber( g->u ) ) );
108 r.push_back( std::to_string( obj.get_warmth() ) );
109 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
110 r.push_back( std::to_string( obj.get_storage() / units::legacy_volume_factor ) );
111 r.push_back( std::to_string( obj.get_coverage() ) );
112 r.push_back( std::to_string( obj.bash_resist() ) );
113 r.push_back( std::to_string( obj.cut_resist() ) );
114 r.push_back( std::to_string( obj.bullet_resist() ) );
115 r.push_back( std::to_string( obj.acid_resist() ) );
116 r.push_back( std::to_string( obj.fire_resist() ) );
117 rows.push_back( r );
118 };
119
120 body_part bp = opts.empty() ? num_bp : get_body_part_token( opts.front() );
121
122 for( const itype *e : item_controller->all() ) {
123 if( e->armor ) {
124 item obj( e );
125 if( bp == num_bp || obj.covers( bp ) ) {
126 if( obj.has_flag( flag_VARSIZE ) ) {
127 obj.set_flag( "FIT" );
128 }
129 dump( obj );
130 }
131 }
132 }
133
134 } else if( what == "EDIBLE" ) {
135 header = {
136 "Name", "Volume", "Weight", "Stack", "Calories", "Quench", "Healthy"
137 };
138 for( const auto &v : vitamin::all() ) {
139 header.push_back( v.second.name() );
140 }
141 auto dump = [&rows]( const item & obj ) {
142 std::vector<std::string> r;
143 r.push_back( obj.tname( 1, false ) );
144 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
145 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
146 r.push_back( std::to_string( obj.type->stack_size ) );
147 r.push_back( std::to_string( obj.get_comestible()->default_nutrition.kcal ) );
148 r.push_back( std::to_string( obj.get_comestible()->quench ) );
149 r.push_back( std::to_string( obj.get_comestible()->healthy ) );
150 auto vits = obj.get_comestible()->default_nutrition.vitamins;
151 for( const auto &v : vitamin::all() ) {
152 r.push_back( std::to_string( vits[ v.first ] ) );
153 }
154 rows.push_back( r );
155 };
156
157 for( const itype *e : item_controller->all() ) {
159
160 if( food.is_food() && g->u.can_eat( food ).success() ) {
161 dump( food );
162 }
163 }
164
165 } else if( what == "GUN" ) {
166 header = {
167 "Name", "Ammo", "Volume", "Weight", "Capacity",
168 "Range", "Dispersion", "Effective recoil", "Damage", "Pierce",
169 "Aim time", "Effective range", "Snapshot range", "Max range"
170 };
171
172 std::set<std::string> locations;
173 for( const itype *e : item_controller->all() ) {
174 if( e->gun ) {
175 std::transform( e->gun->valid_mod_locations.begin(),
176 e->gun->valid_mod_locations.end(),
177 std::inserter( locations, locations.begin() ),
178 []( const std::pair<gunmod_location, int> &q ) {
179 return q.first.name();
180 } );
181 }
182 }
183 for( const auto &e : locations ) {
184 header.push_back( e );
185 }
186
187 auto dump = [&rows, &locations]( const standard_npc & who, const item & obj ) {
188 std::vector<std::string> r;
189 r.push_back( obj.tname( 1, false ) );
190 r.push_back( !obj.ammo_types().empty() ? enumerate_as_string( obj.ammo_types().begin(),
191 obj.ammo_types().end(), []( const ammotype & at ) {
192 return at.str();
194 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
195 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
196 r.push_back( std::to_string( obj.ammo_capacity() ) );
197 r.push_back( std::to_string( obj.gun_range() ) );
198 r.push_back( std::to_string( obj.gun_dispersion() ) );
199 r.push_back( std::to_string( obj.gun_recoil() ) );
200 damage_instance damage = obj.gun_damage();
201 r.push_back( std::to_string( damage.total_damage() ) );
202 r.push_back( std::to_string( damage.empty() ? 0 : ( *damage.begin() ).res_pen ) );
203
204 r.push_back( std::to_string( who.gun_engagement_moves( obj ) ) );
205
206 for( const auto &e : locations ) {
207 const auto &vml = obj.type->gun->valid_mod_locations;
208 const auto iter = vml.find( e );
209 r.push_back( std::to_string( iter != vml.end() ? iter->second : 0 ) );
210 }
211 rows.push_back( r );
212 };
213 for( const itype *e : item_controller->all() ) {
214 if( e->gun ) {
215 item gun( e );
216 if( !gun.magazine_integral() ) {
217 gun.put_in( item( gun.magazine_default() ) );
218 }
219 gun.ammo_set( gun.ammo_default( false ), gun.ammo_capacity() );
220
221 dump( test_npcs[ "S1" ], gun );
222
223 if( gun.type->gun->barrel_length > 0_ml ) {
224 gun.put_in( item( "barrel_small" ) );
225 dump( test_npcs[ "S1" ], gun );
226 }
227 }
228 }
229
230 } else if( what == "RECIPE" ) {
231
232 // optionally filter recipes to include only those using specified skills
233 recipe_subset dict;
234 for( const auto &r : recipe_dict ) {
235 if( opts.empty() || std::any_of( opts.begin(), opts.end(), [&r]( const std::string & s ) {
236 if( r.second.skill_used == skill_id( s ) && r.second.difficulty > 0 ) {
237 return true;
238 }
239 const auto iter = r.second.required_skills.find( skill_id( s ) );
240 return iter != r.second.required_skills.end() && iter->second > 0;
241 } ) ) {
242 dict.include( &r.second );
243 }
244 }
245
246 // only consider skills that are required by at least one recipe
247 std::vector<Skill> sk;
248 std::copy_if( Skill::skills.begin(), Skill::skills.end(),
249 std::back_inserter( sk ), [&dict]( const Skill & s ) {
250 return std::any_of( dict.begin(), dict.end(), [&s]( const recipe * r ) {
251 return r->skill_used == s.ident() ||
252 r->required_skills.find( s.ident() ) != r->required_skills.end();
253 } );
254 } );
255
256 header = { "Result" };
257
258 for( const auto &e : sk ) {
259 header.push_back( e.ident().str() );
260 }
261
262 for( const recipe *e : dict ) {
263 std::vector<std::string> r;
264 r.push_back( e->result_name() );
265 for( const auto &s : sk ) {
266 if( e->skill_used == s.ident() ) {
267 r.push_back( std::to_string( e->difficulty ) );
268 } else {
269 auto iter = e->required_skills.find( s.ident() );
270 r.push_back( std::to_string( iter != e->required_skills.end() ? iter->second : 0 ) );
271 }
272 }
273 rows.push_back( r );
274 }
275
276 } else if( what == "VEHICLE" ) {
277 header = {
278 "Name", "Weight (empty)", "Weight (fueled)",
279 "Max velocity (mph)", "Safe velocity (mph)", "Acceleration (mph/turn)",
280 "Aerodynamics coeff", "Rolling coeff", "Static Drag", "Offroad %"
281 };
282 auto dump = [&rows]( const vproto_id & obj ) {
283 vehicle veh_empty( obj, 0, 0 );
284 vehicle veh_fueled( obj, 100, 0 );
285
286 std::vector<std::string> r;
287 r.push_back( veh_empty.name );
288 r.push_back( std::to_string( to_kilogram( veh_empty.total_mass() ) ) );
289 r.push_back( std::to_string( to_kilogram( veh_fueled.total_mass() ) ) );
290 r.push_back( std::to_string( veh_fueled.max_velocity() / 100 ) );
291 r.push_back( std::to_string( veh_fueled.safe_velocity() / 100 ) );
292 r.push_back( std::to_string( veh_fueled.acceleration() / 100 ) );
293 r.push_back( std::to_string( veh_fueled.coeff_air_drag() ) );
294 r.push_back( std::to_string( veh_fueled.coeff_rolling_drag() ) );
295 r.push_back( std::to_string( veh_fueled.static_drag( false ) ) );
296 r.push_back( std::to_string( static_cast<int>( 50 *
297 veh_fueled.k_traction( veh_fueled.wheel_area() ) ) ) );
298 rows.push_back( r );
299 };
300 for( auto &e : vehicle_prototype::get_all() ) {
301 dump( e );
302 }
303
304 } else if( what == "VPART" ) {
305 header = {
306 "Name", "Location", "Weight", "Size"
307 };
308 auto dump = [&rows]( const vpart_info & obj ) {
309 std::vector<std::string> r;
310 r.push_back( obj.name() );
311 r.push_back( obj.location );
312 int w = std::ceil( to_gram( item( obj.item ).weight() ) / 1000.0 );
313 r.push_back( std::to_string( w ) );
314 r.push_back( std::to_string( obj.size / units::legacy_volume_factor ) );
315 rows.push_back( r );
316 };
317 for( const auto &e : vpart_info::all() ) {
318 dump( e.second );
319 }
320
321 } else {
322 std::cerr << "unknown argument: " << what << std::endl;
323 return false;
324 }
325
326 rows.erase( std::remove_if( rows.begin(), rows.end(), []( const std::vector<std::string> &e ) {
327 return e.empty();
328 } ), rows.end() );
329
330 if( scol >= 0 ) {
331 std::sort( rows.begin(), rows.end(), [&scol]( const std::vector<std::string> &lhs,
332 const std::vector<std::string> &rhs ) {
333 return localized_compare( lhs[ scol ], rhs[ scol ] );
334 } );
335 }
336
337 rows.erase( std::unique( rows.begin(), rows.end() ), rows.end() );
338
339 switch( mode ) {
340 case dump_mode::TSV:
341 rows.insert( rows.begin(), header );
342 for( const auto &r : rows ) {
343 // NOLINTNEXTLINE(cata-text-style): using tab to align the output
344 std::copy( r.begin(), r.end() - 1, std::ostream_iterator<std::string>( std::cout, "\t" ) );
345 std::cout << r.back() << "\n";
346 }
347 break;
348
349 case dump_mode::HTML:
350 std::cout << "<table>";
351
352 std::cout << "<thead>";
353 std::cout << "<tr>";
354 for( const auto &col : header ) {
355 std::cout << "<th>" << col << "</th>";
356 }
357 std::cout << "</tr>";
358 std::cout << "</thead>";
359
360 std::cout << "<tdata>";
361 for( const auto &r : rows ) {
362 std::cout << "<tr>";
363 for( const auto &col : r ) {
364 std::cout << "<td>" << col << "</td>";
365 }
366 std::cout << "</tr>";
367 }
368 std::cout << "</tdata>";
369
370 std::cout << "</table>";
371 break;
372 }
373
374 return true;
375}
body_part get_body_part_token(const std::string &id)
Returns the matching body_part token from the corresponding body_part string.
Definition: bodypart.cpp:180
body_part
Definition: bodypart.h:39
std::string to_string(const time_duration &d)
Returns a string showing a duration.
Definition: calendar.cpp:327
Definition: skill.h:33
static std::vector< Skill > skills
Definition: skill.h:49
const skill_id & ident() const
Definition: skill.h:65
bool load_packs(const std::string &msg, const std::vector< mod_id > &packs, loading_ui &ui)
Load content packs.
Definition: game.cpp:2968
units::mass weight(bool include_contents=true, bool integral=false) const
Definition: item.cpp:4844
void put_in(const item &payload)
Puts the given item into this one, no checks are performed.
Definition: item.cpp:987
item & ammo_set(const itype_id &ammo, int qty=-1)
Filter setting the ammo for this instance Any existing ammo is removed.
Definition: item.cpp:587
std::set< constrecipe * >::const_iterator begin() const
std::set< constrecipe * >::const_iterator end() const
void include(const recipe *r, int custom_difficulty=-1)
Include a recipe to the subset.
Definition: recipe.h:35
An NPC with standard stats.
Definition: npc.h:1394
static const std::map< vitamin_id, vitamin > & all()
Get all currently loaded vitamins.
Definition: vitamin.cpp:98
static const std::map< vpart_id, vpart_info > & all()
Definition: veh_type.cpp:694
static const std::string flag_VARSIZE("VARSIZE")
std::unique_ptr< Item_factory > item_controller
void transform(player &p, const tripoint &pos)
Transform the examined object into the object specified by its transforms_into property.
Definition: iexamine.cpp:1588
static constexpr volume legacy_volume_factor
Definition: units_volume.h:50
constexpr value_type to_gram(const quantity< value_type, mass_in_milligram_tag > &v)
Definition: units_mass.h:67
constexpr value_type to_kilogram(const quantity< value_type, mass_in_milligram_tag > &v)
Definition: units_mass.h:73
std::string enumerate_as_string(const _Container &values, enumeration_conjunction conj=enumeration_conjunction::and_)
Definition: output.h:679
recipe_dictionary recipe_dict
float total_damage() const
Definition: damage.cpp:75
std::vector< damage_unit >::iterator begin()
Definition: damage.cpp:120
bool empty() const
Definition: damage.cpp:88
Default (or randomized) charges except if counted by charges then only one charge.
Definition: item.h:196
Definition: itype.h:836
static std::vector< vproto_id > get_all()
Definition: veh_type.cpp:1157
string_id< MOD_INFORMATION > mod_id
Definition: type_id.h:91

References _, vitamin::all(), item::ammo_capacity(), item::ammo_default(), item::ammo_set(), damage_instance::begin(), item::covers(), damage_instance::empty(), enumerate_as_string(), DynamicDataLoader::finalize_loaded_data(), flag_VARSIZE(), g, get_body_part_token(), DynamicDataLoader::get_instance(), itype::gun, item::has_flag(), Skill::ident(), recipe_subset::include(), item_controller, itype_id, units::legacy_volume_factor, load_core_data(), load_packs(), anonymous_namespace{overmap_location.cpp}::locations, item::magazine_default(), item::magazine_integral(), none, num_bp, item::put_in(), recipe_dict, item::set_flag(), Skill::skills, units::to_gram(), to_string(), damage_instance::total_damage(), iexamine::transform(), calendar::turn, and item::type.

◆ events()

event_bus & game::events ( )

Definition at line 3078 of file game.cpp.

3079{
3080 return *event_bus_ptr;
3081}
pimpl< event_bus > event_bus_ptr
Definition: game.h:1001

References event_bus_ptr.

Referenced by cleanup_at_end(), and game().

◆ exam_vehicle()

void game::exam_vehicle ( vehicle veh,
const point cp = point_zero 
)

open vehicle interaction screen

Definition at line 5273 of file game.cpp.

5274{
5275 if( veh.magic ) {
5276 add_msg( m_info, _( "This is your %s" ), veh.name );
5277 return;
5278 }
5279 auto act = veh_interact::run( veh, c );
5280 if( act ) {
5281 u.moves = 0;
5283 }
5284}
static player_activity run(vehicle &veh, const point &p)
bool magic
Definition: vehicle.h:1847
constexpr double c
Definition: magic.cpp:1032
activity_id act
Definition: sounds.cpp:75

References _, act, add_msg(), Character::assign_activity(), c, m_info, vehicle::magic, Creature::moves, vehicle::name, veh_interact::run(), and u.

◆ examine() [1/2]

void game::examine ( )
private

Definition at line 5653 of file game.cpp.

5654{
5655 // if we are driving a vehicle, examine the
5656 // current tile without asking.
5657 const optional_vpart_position vp = m.veh_at( u.pos() );
5658 if( vp && vp->vehicle().player_in_control( u ) ) {
5659 examine( u.pos() );
5660 return;
5661 }
5662
5663 const cata::optional<tripoint> examp_ = choose_adjacent_highlight( _( "Examine where?" ),
5664 _( "There is nothing that can be examined nearby." ),
5665 ACTION_EXAMINE, false );
5666 if( !examp_ ) {
5667 return;
5668 }
5669 u.manual_examine = true;
5670 examine( *examp_ );
5671 u.manual_examine = false;
5672}
cata::optional< tripoint > choose_adjacent_highlight(const std::string &message, const std::string &failure_message, const action_id action, bool allow_vertical)
Request player input of adjacent tile with highlighting, possibly on different z-level.
Definition: action.cpp:1019
@ ACTION_EXAMINE
Examine or pick up items from adjacent square.
Definition: action.h:105
void examine()
Definition: game.cpp:5653
bool manual_examine
Definition: player.h:698

References _, ACTION_EXAMINE, choose_adjacent_highlight(), examine(), m, player::manual_examine, Character::pos(), u, and map::veh_at().

Referenced by examine(), and handle_action().

◆ examine() [2/2]

void game::examine ( const tripoint p)
private

Definition at line 5741 of file game.cpp.

5742{
5743 if( disable_robot( examp ) ) {
5744 return;
5745 }
5746
5747 Creature *c = critter_at( examp );
5748 if( c != nullptr ) {
5749 monster *mon = dynamic_cast<monster *>( c );
5750 if( mon != nullptr ) {
5751 add_msg( _( "There is a %s." ), mon->get_name() );
5752 if( mon->has_effect( effect_pet ) && !u.is_mounted() ) {
5753 if( monexamine::pet_menu( *mon ) ) {
5754 return;
5755 }
5756 } else if( mon->has_flag( MF_RIDEABLE_MECH ) && !mon->has_effect( effect_pet ) ) {
5757 if( monexamine::mech_hack( *mon ) ) {
5758 return;
5759 }
5760 } else if( mon->has_flag( MF_PAY_BOT ) ) {
5761 if( monexamine::pay_bot( *mon ) ) {
5762 return;
5763 }
5764 } else if( mon->attitude_to( u ) == Creature::A_FRIENDLY && !u.is_mounted() ) {
5765 if( monexamine::mfriend_menu( *mon ) ) {
5766 return;
5767 }
5768 }
5769 } else if( u.is_mounted() ) {
5770 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5771 }
5772 npc *np = dynamic_cast<npc *>( c );
5773 if( np != nullptr && !u.is_mounted() ) {
5774 if( npc_menu( *np ) ) {
5775 return;
5776 }
5777 } else if( np != nullptr && u.is_mounted() ) {
5778 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5779 }
5780 }
5781
5782 const optional_vpart_position vp = m.veh_at( examp );
5783 if( vp && u.is_mounted() ) {
5784 if( !u.mounted_creature->has_flag( MF_RIDEABLE_MECH ) ) {
5785 add_msg( m_warning, _( "You cannot interact with a vehicle while mounted." ) );
5786 } else {
5787 vp->vehicle().interact_with( examp, vp->part_index() );
5788 return;
5789 }
5790 } else if( vp && !u.is_mounted() ) {
5791 vp->vehicle().interact_with( examp, vp->part_index() );
5792 return;
5793 }
5794
5795 if( m.has_flag( "CONSOLE", examp ) && !u.is_mounted() ) {
5796 use_computer( examp );
5797 return;
5798 } else if( m.has_flag( "CONSOLE", examp ) && u.is_mounted() ) {
5799 add_msg( m_warning, _( "You cannot use a console while mounted." ) );
5800 }
5801 const furn_t &xfurn_t = m.furn( examp ).obj();
5802 const ter_t &xter_t = m.ter( examp ).obj();
5803
5804 const tripoint player_pos = u.pos();
5805
5806 if( m.has_furn( examp ) && !u.is_mounted() ) {
5807 xfurn_t.examine( u, examp );
5808 } else if( m.has_furn( examp ) && u.is_mounted() ) {
5809 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5810 } else {
5811 if( !u.is_mounted() ) {
5812 xter_t.examine( u, examp );
5813 } else if( u.is_mounted() && xter_t.examine == &iexamine::none ) {
5814 xter_t.examine( u, examp );
5815 } else {
5816 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5817 }
5818 }
5819
5820 // Did the player get moved? Bail out if so; our examp probably
5821 // isn't valid anymore.
5822 if( player_pos != u.pos() ) {
5823 return;
5824 }
5825
5826 bool none = true;
5827 if( xter_t.examine != &iexamine::none || xfurn_t.examine != &iexamine::none ) {
5828 none = false;
5829 }
5830
5831 if( !m.tr_at( examp ).is_null() && !u.is_mounted() ) {
5832 iexamine::trap( u, examp );
5833 } else if( !m.tr_at( examp ).is_null() && u.is_mounted() ) {
5834 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5835 }
5836
5837 // In case of teleport trap or somesuch
5838 if( player_pos != u.pos() ) {
5839 return;
5840 }
5841
5842 // Feedback for fire lasting time, this can be judged while mounted
5843 const std::string fire_fuel = get_fire_fuel_string( examp );
5844 if( !fire_fuel.empty() ) {
5845 add_msg( fire_fuel );
5846 }
5847
5848 if( m.has_flag( "SEALED", examp ) ) {
5849 if( none ) {
5850 if( m.has_flag( "UNSTABLE", examp ) ) {
5851 add_msg( _( "The %s is too unstable to remove anything." ), m.name( examp ) );
5852 } else {
5853 add_msg( _( "The %s is firmly sealed." ), m.name( examp ) );
5854 }
5855 }
5856 } else {
5857 //examp has no traps, is a container and doesn't have a special examination function
5858 if( m.tr_at( examp ).is_null() && m.i_at( examp ).empty() &&
5859 m.has_flag( "CONTAINER", examp ) && none ) {
5860 add_msg( _( "It is empty." ) );
5861 } else if( ( m.has_flag( TFLAG_FIRE_CONTAINER, examp ) &&
5862 xfurn_t.examine == &iexamine::fireplace ) ||
5863 xfurn_t.examine == &iexamine::workbench ) {
5864 return;
5865 } else {
5867 if( !u.is_mounted() ) {
5868 pickup::pick_up( examp, 0 );
5869 }
5870 }
5871 }
5872}
shared_ptr_fast< monster > mounted_creature
Definition: character.h:1620
@ A_FRIENDLY
Definition: creature.h:171
void use_computer(const tripoint &p)
Checks to see if a player can use a computer (not illiterate, etc.) and uses if able.
Definition: game.cpp:4803
bool disable_robot(const tripoint &p)
If there is a robot (that can be disabled), query the player and try to disable it.
Definition: game.cpp:9177
bool npc_menu(npc &who)
Returns true if the menu handled stuff and player shouldn't do anything else.
Definition: game.cpp:5544
bool empty() const
Definition: item_stack.cpp:15
bool has_furn(const tripoint &p) const
Definition: map.cpp:1337
const trap & tr_at(const tripoint &p) const
Definition: map.cpp:5120
ter_id ter(const tripoint &p) const
Definition: map.cpp:1492
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
Definition: monster.cpp:1020
std::string get_name() const override
Definition: monster.cpp:487
static const efftype_id effect_pet("pet")
static std::string get_fire_fuel_string(const tripoint &examp)
Definition: game.cpp:5674
@ TFLAG_FIRE_CONTAINER
Definition: mapdata.h:293
void fireplace(player &p, const tripoint &examp)
Definition: iexamine.cpp:2890
void workbench(player &p, const tripoint &examp)
Definition: iexamine.cpp:6071
void none(player &p, const tripoint &examp)
Nothing player can interact with here.
Definition: iexamine.cpp:243
void trap(player &p, const tripoint &examp)
Definition: iexamine.cpp:3789
bool pet_menu(monster &z)
Definition: monexamine.cpp:64
bool mech_hack(monster &z)
Definition: monexamine.cpp:373
bool mfriend_menu(monster &z)
Definition: monexamine.cpp:445
bool pay_bot(monster &z)
Definition: monexamine.cpp:405
void pick_up(const tripoint &p, int min, from_where get_items_from=prompt)
Pick up items; 'g' or ',' or via examine()
Definition: pickup.cpp:571
iexamine_function examine
Definition: mapdata.h:398
Definition: mapdata.h:457
bool is_null() const
Whether this is the null-traps, aka no trap at all.
Definition: trap.cpp:245

References _, Creature::A_FRIENDLY, add_msg(), monster::attitude_to(), c, critter_at(), disable_robot(), effect_pet, item_stack::empty(), map_data_common_t::examine, iexamine::fireplace(), map::furn(), get_fire_fuel_string(), monster::get_name(), Creature::has_effect(), map::has_flag(), monster::has_flag(), map::has_furn(), map::i_at(), Character::is_mounted(), trap::is_null(), m, m_warning, monexamine::mech_hack(), MF_PAY_BOT, MF_RIDEABLE_MECH, monexamine::mfriend_menu(), Character::mounted_creature, map::name(), none, iexamine::none(), npc_menu(), int_id< T >::obj(), monexamine::pay_bot(), monexamine::pet_menu(), pickup::pick_up(), Character::pos(), sounds::process_sound_markers(), map::ter(), TFLAG_FIRE_CONTAINER, map::tr_at(), iexamine::trap(), u, use_computer(), map::veh_at(), and iexamine::workbench().

◆ extended_description()

void game::extended_description ( const tripoint p)

Long description of (visible) things at tile.

Definition at line 50 of file descriptions.cpp.

51{
53 const int top = 3;
54 int width = 0;
55 catacurses::window w_head;
56 catacurses::window w_main;
57 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
58 const int left = 0;
59 const int right = TERMX;
60 const int bottom = TERMY;
61 width = right - left;
62 const int height = bottom - top;
63 w_head = catacurses::newwin( top, TERMX, point_zero );
64 w_main = catacurses::newwin( height, width, point( left, top ) );
65 ui.position( point_zero, point( TERMX, TERMY ) );
66 } );
67 ui.mark_resize();
68
69 // Default to critter (if any), furniture (if any), then terrain.
71 if( seen_critter( *this, p ) != nullptr ) {
73 } else if( get_map().has_furn( p ) ) {
75 }
76
77 std::string action;
78 input_context ctxt( "EXTENDED_DESCRIPTION" );
79 ctxt.register_action( "CREATURE" );
80 ctxt.register_action( "FURNITURE" );
81 ctxt.register_action( "TERRAIN" );
82 ctxt.register_action( "CONFIRM" );
83 ctxt.register_action( "QUIT" );
84 ctxt.register_action( "HELP_KEYBINDINGS" );
85
86 ui.on_redraw( [&]( const ui_adaptor & ) {
87 werase( w_head );
89 _( "[%s] describe creatures, [%s] describe furniture, "
90 "[%s] describe terrain, [%s] close." ),
91 ctxt.get_desc( "CREATURE" ), ctxt.get_desc( "FURNITURE" ),
92 ctxt.get_desc( "TERRAIN" ), ctxt.get_desc( "QUIT" ) );
93
94 // Set up line drawings
95 for( int i = 0; i < TERMX; i++ ) {
96 mvwputch( w_head, point( i, top - 1 ), c_white, LINE_OXOX );
97 }
98
99 wnoutrefresh( w_head );
100
101 std::string desc;
102 // Allow looking at invisible tiles - player may want to examine hallucinations etc.
103 switch( cur_target ) {
105 const Creature *critter = seen_critter( *this, p );
106 if( critter != nullptr ) {
107 desc = critter->extended_description();
108 } else {
109 desc = _( "You do not see any creature here." );
110 }
111 }
112 break;
114 if( !u.sees( p ) || !m.has_furn( p ) ) {
115 desc = _( "You do not see any furniture here." );
116 } else {
117 const furn_id fid = m.furn( p );
118 desc = fid.obj().extended_description();
119 }
120 break;
122 if( !u.sees( p ) ) {
123 desc = _( "You can't see the terrain here." );
124 } else {
125 const ter_id tid = m.ter( p );
126 desc = tid.obj().extended_description();
127 }
128 break;
129 }
130
131 std::string signage = m.get_signage( p );
132 if( !signage.empty() ) {
133 // NOLINTNEXTLINE(cata-text-style): the question mark does not end a sentence
134 desc += u.has_trait( trait_ILLITERATE ) ? _( "\nSign: ???" ) : string_format( _( "\nSign: %s" ),
135 signage );
136 }
137
138 werase( w_main );
139 fold_and_print_from( w_main, point_zero, width, 0, c_light_gray, desc );
140 wnoutrefresh( w_main );
141 } );
142
143 do {
145 action = ctxt.handle_input();
146 if( action == "CREATURE" ) {
147 cur_target = description_target::creature;
148 } else if( action == "FURNITURE" ) {
150 } else if( action == "TERRAIN" ) {
151 cur_target = description_target::terrain;
152 }
153 } while( action != "CONFIRM" && action != "QUIT" );
154}
virtual std::string extended_description() const =0
friend map & get_map()
Definition: map.cpp:141
std::string get_signage(const tripoint &p) const
Definition: map.cpp:3978
static const trait_id trait_ILLITERATE("ILLITERATE")
static const Creature * seen_critter(const game &g, const tripoint &p)
description_target
int fold_and_print_from(const catacurses::window &w, const point &begin, int width, int begin_line, const nc_color &base_color, const std::string &text)
Like fold_and_print, but starts the output with the N-th line of the folded string.
Definition: output.cpp:311
std::string extended_description() const

References _, action, c_light_gray, c_white, creature, map_data_common_t::extended_description(), Creature::extended_description(), fold_and_print_from(), map::furn(), furniture, input_context::get_desc(), get_map, map::get_signage(), input_context::handle_input(), map::has_furn(), Character::has_trait(), left, LINE_OXOX, m, mvwprintz(), mvwputch(), catacurses::newwin(), int_id< T >::obj(), point_zero, ui_manager::redraw(), input_context::register_action(), right, seen_critter(), Character::sees(), string_format(), map::ter(), TERMX, TERMY, terrain, trait_ILLITERATE, u, catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by look_around().

◆ find_nearby_items()

std::vector< map_item_stack > game::find_nearby_items ( int  iRadius)
private

Definition at line 7189 of file game.cpp.

7190{
7191 std::map<std::string, map_item_stack> temp_items;
7192 std::vector<map_item_stack> ret;
7193 std::vector<std::string> item_order;
7194
7195 if( u.is_blind() ) {
7196 return ret;
7197 }
7198
7199 for( auto &points_p_it : closest_points_first( u.pos(), iRadius ) ) {
7200 if( points_p_it.y >= u.posy() - iRadius && points_p_it.y <= u.posy() + iRadius &&
7201 u.sees( points_p_it ) &&
7202 m.sees_some_items( points_p_it, u ) ) {
7203
7204 for( auto &elem : m.i_at( points_p_it ) ) {
7205 const std::string name = elem.tname();
7206 const tripoint relative_pos = points_p_it - u.pos();
7207
7208 if( std::find( item_order.begin(), item_order.end(), name ) == item_order.end() ) {
7209 item_order.push_back( name );
7210 temp_items[name] = map_item_stack( &elem, relative_pos );
7211 } else {
7212 temp_items[name].add_at_pos( &elem, relative_pos );
7213 }
7214 }
7215 }
7216 }
7217
7218 for( auto &elem : item_order ) {
7219 ret.push_back( temp_items[elem] );
7220 }
7221
7222 return ret;
7223}
bool is_blind() const
Returns true if the player isn't able to see.
Definition: character.cpp:6334
std::vector< coords::coord_point< Point, Origin, Scale > > closest_points_first(const coords::coord_point< Point, Origin, Scale > &loc, int min_dist, int max_dist)
Definition: coordinates.h:596

References closest_points_first(), detail::find(), map::i_at(), Character::is_blind(), m, om_direction::name(), Character::pos(), Character::posy(), cata::hash64_detail::ret, Character::sees(), map::sees_some_items(), and u.

Referenced by list_items_monsters().

◆ find_npc()

npc * game::find_npc ( character_id  id)

Find the npc with the given ID.

Returns NULL if the npc could not be found. Searches all loaded overmaps.

Definition at line 1953 of file game.cpp.

1954{
1955 return overmap_buffer.find_npc( id ).get();
1956}

References overmapbuffer::find_npc(), and overmap_buffer.

Referenced by critter_by_id().

◆ find_or_make_stairs()

cata::optional< tripoint > game::find_or_make_stairs ( map mp,
int  z_after,
bool &  rope_ladder,
bool  peeking 
)

Returns the other end of the stairs (if any).

May query, affect u etc.

Definition at line 10942 of file game.cpp.

10944{
10945 const int omtilesz = SEEX * 2;
10946 real_coords rc( m.getabs( point( u.posx(), u.posy() ) ) );
10947 tripoint omtile_align_start( m.getlocal( rc.begin_om_pos() ), z_after );
10948 tripoint omtile_align_end( omtile_align_start + point( -1 + omtilesz, -1 + omtilesz ) );
10949
10950 // Try to find the stairs.
10952 int best = INT_MAX;
10953 const int movez = z_after - get_levz();
10954 const bool going_down_1 = movez == -1;
10955 const bool going_up_1 = movez == 1;
10956 // If there are stairs on the same x and y as we currently are, use those
10957 if( going_down_1 && mp.has_flag( TFLAG_GOES_UP, u.pos() + tripoint_below ) ) {
10958 stairs.emplace( u.pos() + tripoint_below );
10959 }
10960 if( going_up_1 && mp.has_flag( TFLAG_GOES_DOWN, u.pos() + tripoint_above ) ) {
10961 stairs.emplace( u.pos() + tripoint_above );
10962 }
10963 // We did not find stairs directly above or below, so search the map for them
10964 if( !stairs.has_value() ) {
10965 for( const tripoint &dest : m.points_in_rectangle( omtile_align_start, omtile_align_end ) ) {
10966 if( rl_dist( u.pos(), dest ) <= best &&
10967 ( ( going_down_1 && mp.has_flag( TFLAG_GOES_UP, dest ) ) ||
10968 ( going_up_1 && ( mp.has_flag( TFLAG_GOES_DOWN, dest ) ||
10969 mp.ter( dest ) == t_manhole_cover ) ) ||
10970 ( ( movez == 2 || movez == -2 ) && mp.ter( dest ) == t_elevator ) ) ) {
10971 stairs.emplace( dest );
10972 best = rl_dist( u.pos(), dest );
10973 }
10974 }
10975 }
10976
10977 if( stairs.has_value() ) {
10978 if( Creature *blocking_creature = critter_at( stairs.value() ) ) {
10979 npc *guy = dynamic_cast<npc *>( blocking_creature );
10980 monster *mon = dynamic_cast<monster *>( blocking_creature );
10981 bool would_move = ( guy && !guy->is_enemy() ) || ( mon && mon->friendly == -1 );
10982 bool can_displace = find_empty_spot_nearby( *stairs ).has_value();
10983 std::string cr_name = blocking_creature->get_name();
10984 std::string msg;
10985 if( guy ) {
10986 //~ %s is the name of hostile NPC
10987 msg = string_format( _( "%s is in the way!" ), cr_name );
10988 } else {
10989 //~ %s is some monster
10990 msg = string_format( _( "There's a %s in the way!" ), cr_name );
10991 }
10992
10993 if( ( peeking && !would_move ) || !can_displace || ( !would_move && !query_yn(
10994 //~ %s is a warning about monster/hostile NPC in the way, e.g. "There's a zombie in the way!"
10995 _( "%s Attempt to push past? You may have to fight your way back up." ), msg ) ) ) {
10996 add_msg( msg );
10997 return cata::nullopt;
10998 }
10999 }
11000 return stairs;
11001 }
11002
11003 // No stairs found! Try to make some
11004 rope_ladder = false;
11005 stairs.emplace( u.pos() );
11006 stairs->z = z_after;
11007 // Check the destination area for lava.
11008 if( mp.ter( *stairs ) == t_lava ) {
11009 if( movez < 0 &&
11010 !query_yn(
11011 _( "There is a LOT of heat coming out of there, even the stairs have melted away. Jump down? You won't be able to get back up." ) ) ) {
11012 return cata::nullopt;
11013 } else if( movez > 0 &&
11014 !query_yn(
11015 _( "There is a LOT of heat coming out of there. Push through the half-molten rocks and ascend? You will not be able to get back down." ) ) ) {
11016 return cata::nullopt;
11017 }
11018
11019 return stairs;
11020 }
11021
11022 if( movez > 0 ) {
11023 if( !mp.has_flag( "GOES_DOWN", *stairs ) ) {
11024 if( !query_yn( _( "You may be unable to return back down these stairs. Continue up?" ) ) ) {
11025 return cata::nullopt;
11026 }
11027 }
11028 // Manhole covers need this to work
11029 // Maybe require manhole cover here and fail otherwise?
11030 return stairs;
11031 }
11032
11033 if( mp.impassable( *stairs ) ) {
11034 popup( _( "Halfway down, the way down becomes blocked off." ) );
11035 return cata::nullopt;
11036 }
11037
11038 if( u.has_trait( trait_id( "WEB_RAPPEL" ) ) ) {
11039 if( query_yn( _( "There is a sheer drop halfway down. Web-descend?" ) ) ) {
11040 rope_ladder = true;
11041 if( ( rng( 4, 8 ) ) < u.get_skill_level( skill_dodge ) ) {
11042 add_msg( _( "You attach a web and dive down headfirst, flipping upright and landing on your feet." ) );
11043 } else {
11044 add_msg( _( "You securely web up and work your way down, lowering yourself safely." ) );
11045 }
11046 } else {
11047 return cata::nullopt;
11048 }
11049 } else if( u.has_trait( trait_VINES2 ) || u.has_trait( trait_VINES3 ) ) {
11050 if( query_yn( _( "There is a sheer drop halfway down. Use your vines to descend?" ) ) ) {
11051 if( u.has_trait( trait_VINES2 ) ) {
11052 if( query_yn( _( "Detach a vine? It'll hurt, but you'll be able to climb back up…" ) ) ) {
11053 rope_ladder = true;
11054 add_msg( m_bad, _( "You descend on your vines, though leaving a part of you behind stings." ) );
11055 u.mod_pain( 5 );
11056 u.apply_damage( nullptr, bodypart_id( "torso" ), 5 );
11057 u.mod_stored_nutr( 10 );
11058 u.mod_thirst( 10 );
11059 } else {
11060 add_msg( _( "You gingerly descend using your vines." ) );
11061 }
11062 } else {
11063 add_msg( _( "You effortlessly lower yourself and leave a vine rooted for future use." ) );
11064 rope_ladder = true;
11065 u.mod_stored_nutr( 10 );
11066 u.mod_thirst( 10 );
11067 }
11068 } else {
11069 return cata::nullopt;
11070 }
11071 } else if( u.has_amount( itype_grapnel, 1 ) ) {
11072 if( query_yn( _( "There is a sheer drop halfway down. Climb your grappling hook down?" ) ) ) {
11073 rope_ladder = true;
11075 } else {
11076 return cata::nullopt;
11077 }
11078 } else if( u.has_amount( itype_rope_30, 1 ) ) {
11079 if( query_yn( _( "There is a sheer drop halfway down. Climb your rope down?" ) ) ) {
11080 rope_ladder = true;
11082 } else {
11083 return cata::nullopt;
11084 }
11085 } else if( !query_yn( _( "There is a sheer drop halfway down. Jump?" ) ) ) {
11086 return cata::nullopt;
11087 }
11088
11089 return stairs;
11090}
int_id< body_part_type > bodypart_id
Definition: bodypart.h:23
void apply_damage(Creature *source, bodypart_id hurt, int dam, bool bypass_med=false) override
Actually hurt the player, hurts a body_part directly, no armor reduction.
Definition: character.cpp:8398
std::list< item > use_amount(itype_id it, int quantity, const std::function< bool(const item &)> &filter=return_true< item >)
Definition: character.cpp:9617
virtual void mod_thirst(int nthirst)
Definition: character.cpp:4407
virtual void mod_stored_nutr(int nnutr)
Definition: character.cpp:4297
int get_skill_level(const skill_id &ident) const
Definition: character.cpp:3335
T & emplace(Args &&... args)
Definition: optional.h:143
constexpr bool has_value() const noexcept
Definition: optional.h:120
tripoint getlocal(const tripoint &p) const
Inverse of getabs.
Definition: map.cpp:8084
bool impassable(const tripoint &p) const
Definition: map.cpp:1789
tripoint_range< tripoint > points_in_rectangle(const tripoint &from, const tripoint &to) const
Definition: map.cpp:8417
bool is_enemy() const
Definition: npc.cpp:2040
void mod_pain(int npain) override
Modifies a pain value by player traits before passing it to Creature::mod_pain()
Definition: player.cpp:1092
static const trait_id trait_VINES2("VINES2")
static const skill_id skill_dodge("dodge")
static cata::optional< tripoint > find_empty_spot_nearby(const tripoint &pos)
Definition: game.cpp:10478
static const itype_id itype_rope_30("rope_30")
static const itype_id itype_grapnel("grapnel")
static const trait_id trait_VINES3("VINES3")
ter_id t_manhole_cover
Definition: mapdata.cpp:720
ter_id t_lava
Definition: mapdata.cpp:695
ter_id t_elevator
Definition: mapdata.cpp:723
@ TFLAG_GOES_DOWN
Definition: mapdata.h:308
@ TFLAG_GOES_UP
Definition: mapdata.h:309
static constexpr nullopt_t nullopt
Definition: optional.h:22
static constexpr tripoint tripoint_below
Definition: point.h:295
static constexpr tripoint tripoint_above
Definition: point.h:294

References _, add_msg(), Character::apply_damage(), real_coords::begin_om_pos(), critter_at(), cata::optional< T >::emplace(), find_empty_spot_nearby(), monster::friendly, get_levz(), Character::get_skill_level(), map::getabs(), map::getlocal(), visitable< T >::has_amount(), map::has_flag(), Character::has_trait(), cata::optional< T >::has_value(), map::impassable(), npc::is_enemy(), itype_grapnel, itype_rope_30, m, m_bad, player::mod_pain(), Character::mod_stored_nutr(), Character::mod_thirst(), cata::nullopt, map::points_in_rectangle(), popup(), Character::pos(), Character::posx(), Character::posy(), query_yn(), rl_dist(), rng(), SEEX, skill_dodge, string_format(), t_elevator, t_lava, t_manhole_cover, map::ter(), TFLAG_GOES_DOWN, TFLAG_GOES_UP, trait_VINES2, trait_VINES3, tripoint_above, tripoint_below, u, Character::use_amount(), and cata::optional< T >::value().

Referenced by vertical_move().

◆ fling_creature()

void game::fling_creature ( Creature c,
const units::angle dir,
float  flvel,
bool  controlled = false,
bool  suppress_map_update = false 
)

Flings the input creature in the given direction.

Definition at line 10303 of file game.cpp.

10305{
10306 if( c == nullptr ) {
10307 debugmsg( "game::fling_creature invoked on null target" );
10308 return;
10309 }
10310
10311 if( c->is_dead_state() ) {
10312 // Flinging a corpse causes problems, don't enable without testing
10313 return;
10314 }
10315
10316 if( c->is_hallucination() ) {
10317 // Don't fling hallucinations
10318 return;
10319 }
10320
10321 int steps = 0;
10322 bool thru = true;
10323 const bool is_u = ( c == &u );
10324 // Don't animate critters getting bashed if animations are off
10325 const bool animate = is_u || get_option<bool>( "ANIMATIONS" );
10326
10327 player *p = dynamic_cast<player *>( c );
10328
10329 tileray tdir( dir );
10330 int range = flvel / 10;
10331 tripoint pt = c->pos();
10332 while( range > 0 ) {
10333 c->underwater = false;
10334 // TODO: Check whenever it is actually in the viewport
10335 // or maybe even just redraw the changed tiles
10336 bool seen = is_u || u.sees( *c ); // To avoid redrawing when not seen
10337 tdir.advance();
10338 pt.x = c->posx() + tdir.dx();
10339 pt.y = c->posy() + tdir.dy();
10340 float force = 0;
10341
10342 if( monster *const mon_ptr = critter_at<monster>( pt ) ) {
10343 monster &critter = *mon_ptr;
10344 // Approximate critter's "stopping power" with its max hp
10345 force = std::min<float>( 1.5f * critter.type->hp, flvel );
10346 const int damage = rng( force, force * 2.0f ) / 6;
10347 c->impact( damage, pt );
10348 // Multiply zed damage by 6 because no body parts
10349 const int zed_damage = std::max( 0,
10350 ( damage - critter.get_armor_bash( bodypart_id( "torso" ) ) ) * 6 );
10351 // TODO: Pass the "flinger" here - it's not the flung critter that deals damage
10352 critter.apply_damage( c, bodypart_id( "torso" ), zed_damage );
10353 critter.check_dead_state();
10354 if( !critter.is_dead() ) {
10355 thru = false;
10356 }
10357 } else if( m.impassable( pt ) ) {
10358 if( !m.veh_at( pt ).obstacle_at_part() ) {
10359 force = std::min<float>( m.bash_strength( pt ), flvel );
10360 } else {
10361 // No good way of limiting force here
10362 // Keep it 1 less than maximum to make the impact hurt
10363 // but to keep the target flying after it
10364 force = flvel - 1;
10365 }
10366 const int damage = rng( force, force * 2.0f ) / 9;
10367 c->impact( damage, pt );
10368 if( m.is_bashable( pt ) ) {
10369 // Only go through if we successfully make the tile passable
10370 m.bash( pt, flvel );
10371 thru = m.passable( pt );
10372 } else {
10373 thru = false;
10374 }
10375 }
10376
10377 // If the critter dies during flinging, moving it around causes debugmsgs
10378 if( c->is_dead_state() ) {
10379 return;
10380 }
10381
10382 flvel -= force;
10383 if( thru ) {
10384 if( p != nullptr ) {
10385 if( p->in_vehicle ) {
10386 m.unboard_vehicle( p->pos() );
10387 }
10388 // If we're flinging the player around, make sure the map stays centered on them.
10389 if( is_u && !suppress_map_update ) {
10390 update_map( pt.x, pt.y );
10391 } else {
10392 p->setpos( pt );
10393 }
10394 } else if( !critter_at( pt ) ) {
10395 // Dying monster doesn't always leave an empty tile (blob spawning etc.)
10396 // Just don't setpos if it happens - next iteration will do so
10397 // or the monster will stop a tile before the unpassable one
10398 c->setpos( pt );
10399 }
10400 } else {
10401 // Don't zero flvel - count this as slamming both the obstacle and the ground
10402 // although at lower velocity
10403 break;
10404 }
10405 range--;
10406 steps++;
10407 if( animate && ( seen || u.sees( *c ) ) ) {
10411 }
10412 }
10413
10414 // Fall down to the ground - always on the last reached tile
10415 if( !m.has_flag( "SWIMMABLE", c->pos() ) ) {
10416 const trap_id trap_under_creature = m.tr_at( c->pos() ).loadid;
10417 // Didn't smash into a wall or a floor so only take the fall damage
10418 if( thru && trap_under_creature == tr_ledge ) {
10419 m.creature_on_trap( *c, false );
10420 } else {
10421 // Fall on ground
10422 int force = rng( flvel, flvel * 2 ) / 9;
10423 if( controlled ) {
10424 force = std::max( force / 2 - 5, 0 );
10425 }
10426 if( force > 0 ) {
10427 int dmg = c->impact( force, c->pos() );
10428 // TODO: Make landing damage the floor
10429 m.bash( c->pos(), dmg / 4, false, false, false );
10430 }
10431 // Always apply traps to creature i.e. bear traps, tele traps etc.
10432 m.creature_on_trap( *c, false );
10433 }
10434 } else {
10435 c->underwater = true;
10436 if( is_u ) {
10437 if( controlled ) {
10438 add_msg( _( "You dive into water." ) );
10439 } else {
10440 add_msg( m_warning, _( "You fall into water." ) );
10441 }
10442 }
10443 }
10444}
void setpos(const tripoint &p) override
Definition: character.h:856
void check_dead_state()
This function checks the creatures is_dead_state and (if true) calls die.
Definition: creature.cpp:1836
point update_map(player &p)
Definition: game.cpp:11169
int bash_strength(const tripoint &p, bool allow_floor=false) const
Returns max_str of the furniture or terrain at p.
Definition: map.cpp:2443
bash_results bash(const tripoint &p, int str, bool silent=false, bool destroy=false, bool bash_floor=false, const vehicle *bashing_vehicle=nullptr)
Returns a pair where first is whether anything was smashed and second is if it was destroyed.
Definition: map.cpp:3505
void unboard_vehicle(const vpart_reference &, Character *passenger, bool dead_passenger=false)
Definition: map.cpp:1075
bool is_bashable(const tripoint &p, bool allow_floor=false) const
Returns true if there is a bashable vehicle part or the furn/terrain is bashable at p.
Definition: map.cpp:2408
void creature_on_trap(Creature &critter, bool may_avoid=true)
Apply trap effects to the creature, similar to creature_in_field.
Definition: map.cpp:8290
bool passable(const tripoint &p) const
Definition: map.cpp:1794
int get_armor_bash(bodypart_id bp) const override
Definition: monster.cpp:1855
bool is_dead() const
Definition: monster.cpp:2753
void apply_damage(Creature *source, bodypart_id bp, int dam, bool bypass_med=false) override
Definition: monster.cpp:1636
cata::optional< vpart_reference > obstacle_at_part() const
Definition: vehicle.cpp:2493
static const trap_str_id tr_ledge("tr_ledge")
void redraw_invalidated()
Definition: ui_manager.cpp:290
int hp
Definition: mtype.h:267
trap_id loadid
Definition: trap.h:88
int y
Definition: point.h:151
int x
Definition: point.h:150

References _, add_msg(), tileray::advance(), monster::apply_damage(), map::bash(), map::bash_strength(), c, Creature::check_dead_state(), map::creature_on_trap(), critter_at(), debugmsg, tileray::dx(), tileray::dy(), monster::get_armor_bash(), map::has_flag(), mtype::hp, map::impassable(), Character::in_vehicle, invalidate_main_ui_adaptor(), map::is_bashable(), monster::is_dead(), trap::loadid, m, m_warning, optional_vpart_position::obstacle_at_part(), map::passable(), Character::pos(), ui_manager::redraw_invalidated(), refresh_display(), rng(), Character::sees(), Character::setpos(), map::tr_at(), tr_ledge, monster::type, u, map::unboard_vehicle(), update_map(), map::veh_at(), tripoint::x, and tripoint::y.

Referenced by moving_vehicle_dismount().

◆ forced_door_closing()

bool game::forced_door_closing ( const tripoint p,
const ter_id door_type,
int  bash_dmg 
)

Definition at line 5286 of file game.cpp.

5287{
5288 // TODO: Z
5289 const int &x = p.x;
5290 const int &y = p.y;
5291 const std::string &door_name = door_type.obj().name();
5292 // sed when player/monsters are knocked back and when moving items out of the way
5293 point kb( x, y );
5294 const auto valid_location = [&]( const tripoint & p ) {
5295 return g->is_empty( p );
5296 };
5298 valid_location ) ) {
5299 kb.x = -pos->x + x + x;
5300 kb.y = -pos->y + y + y;
5301 }
5302 const tripoint kbp( kb, p.z );
5303 if( kbp == p ) {
5304 // can't pushback any creatures anywhere, that means the door can't close.
5305 return false;
5306 }
5307 const bool can_see = u.sees( tripoint( x, y, p.z ) );
5308 player *npc_or_player = critter_at<player>( tripoint( x, y, p.z ), false );
5309 if( npc_or_player != nullptr ) {
5310 if( bash_dmg <= 0 ) {
5311 return false;
5312 }
5313 if( npc_or_player->is_npc() && can_see ) {
5314 add_msg( _( "The %1$s hits the %2$s." ), door_name, npc_or_player->name );
5315 } else if( npc_or_player->is_player() ) {
5316 add_msg( m_bad, _( "The %s hits you." ), door_name );
5317 }
5318 if( npc_or_player->activity ) {
5319 npc_or_player->cancel_activity();
5320 }
5321 // TODO: make the npc angry?
5322 npc_or_player->hitall( bash_dmg, 0, nullptr );
5323 knockback( kbp, p, std::max( 1, bash_dmg / 10 ), -1, 1 );
5324 // TODO: perhaps damage/destroy the gate
5325 // if the npc was really big?
5326 }
5327 if( monster *const mon_ptr = critter_at<monster>( p ) ) {
5328 monster &critter = *mon_ptr;
5329 if( bash_dmg <= 0 ) {
5330 return false;
5331 }
5332 if( can_see ) {
5333 add_msg( _( "The %1$s hits the %2$s." ), door_name, critter.name() );
5334 }
5335 if( critter.type->size <= MS_SMALL ) {
5336 critter.die_in_explosion( nullptr );
5337 } else {
5338 critter.apply_damage( nullptr, bodypart_id( "torso" ), bash_dmg );
5339 critter.check_dead_state();
5340 }
5341 if( !critter.is_dead() && critter.type->size >= MS_HUGE ) {
5342 // big critters simply prevent the gate from closing
5343 // TODO: perhaps damage/destroy the gate
5344 // if the critter was really big?
5345 return false;
5346 }
5347 if( !critter.is_dead() ) {
5348 // Still alive? Move the critter away so the door can close
5349 knockback( kbp, p, std::max( 1, bash_dmg / 10 ), -1, 1 );
5350 if( critter_at( p ) ) {
5351 return false;
5352 }
5353 }
5354 }
5355 if( const optional_vpart_position vp = m.veh_at( p ) ) {
5356 if( bash_dmg <= 0 ) {
5357 return false;
5358 }
5359 vp->vehicle().damage( vp->part_index(), bash_dmg );
5360 if( m.veh_at( p ) ) {
5361 // Check again in case all parts at the door tile
5362 // have been destroyed, if there is still a vehicle
5363 // there, the door can not be closed
5364 return false;
5365 }
5366 }
5367 if( bash_dmg < 0 && !m.i_at( point( x, y ) ).empty() ) {
5368 return false;
5369 }
5370 if( bash_dmg == 0 ) {
5371 for( auto &elem : m.i_at( point( x, y ) ) ) {
5372 if( elem.made_of( LIQUID ) ) {
5373 // Liquids are OK, will be destroyed later
5374 continue;
5375 } else if( elem.volume() < 250_ml ) {
5376 // Dito for small items, will be moved away
5377 continue;
5378 }
5379 // Everything else prevents the door from closing
5380 return false;
5381 }
5382 }
5383
5384 m.ter_set( point( x, y ), door_type );
5385 if( m.has_flag( "NOITEM", point( x, y ) ) ) {
5386 map_stack items = m.i_at( point( x, y ) );
5387 for( map_stack::iterator it = items.begin(); it != items.end(); ) {
5388 if( it->made_of( LIQUID ) ) {
5389 it = items.erase( it );
5390 continue;
5391 }
5392 if( it->made_of( material_id( "glass" ) ) && one_in( 2 ) ) {
5393 if( can_see ) {
5394 add_msg( m_warning, _( "A %s shatters!" ), it->tname() );
5395 } else {
5396 add_msg( m_warning, _( "Something shatters!" ) );
5397 }
5398 it = items.erase( it );
5399 continue;
5400 }
5401 m.add_item_or_charges( kbp, *it );
5402 it = items.erase( it );
5403 }
5404 }
5405 return true;
5406}
int hitall(int dam, int vary, Creature *source)
Harms all body parts for dam, with armor reduction.
Definition: character.cpp:8666
void knockback(const tripoint &s, const tripoint &t, int force, int stun, int dam_mult)
Definition: game.cpp:4573
iterator erase(const_iterator it) override
Definition: map.cpp:147
bool ter_set(const tripoint &p, const ter_id &new_terrain)
Definition: map.cpp:1633
void die_in_explosion(Creature *source)
Definition: monster.cpp:1650
bool is_npc() const override
Definition: player.h:131
bool is_player() const override
Definition: player.h:114
@ MS_SMALL
Definition: creature.h:59
@ MS_HUGE
Definition: creature.h:62
@ LIQUID
Definition: enums.h:175
cata::optional< tripoint > random_point(const map &m, const std::function< bool(const tripoint &)> &predicate)
Same as other random_point with a range enclosing all valid points of the map.
std::string name() const
Definition: mapdata.cpp:511
m_size size
Definition: mtype.h:259

References _, Character::activity, map::add_item_or_charges(), add_msg(), monster::apply_damage(), item_stack::begin(), Character::cancel_activity(), Creature::check_dead_state(), critter_at(), monster::die_in_explosion(), item_stack::end(), map_stack::erase(), g, map::has_flag(), Character::hitall(), map::i_at(), monster::is_dead(), player::is_npc(), player::is_player(), knockback(), LIQUID, m, m_bad, m_warning, MS_HUGE, MS_SMALL, Character::name, map_data_common_t::name(), monster::name(), int_id< T >::obj(), one_in(), map::points_in_radius(), random_point(), Character::sees(), mtype::size, map::ter_set(), monster::type, u, map::veh_at(), point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

◆ gametype()

special_game_id game::gametype ( ) const

Definition at line 627 of file game.cpp.

628{
629 return gamemode ? gamemode->id() : SGAME_NULL;
630}
@ SGAME_NULL
Definition: enums.h:93

References gamemode, and SGAME_NULL.

◆ get_creature_if()

Creature * game::get_creature_if ( const std::function< bool(const Creature &)> &  pred)

Returns a creature matching a predicate.

Only living (not dead) creatures are checked. Returns nullptr if no creature matches the predicate. There is no guarantee which creature is returned when several creatures match.

Definition at line 12516 of file game.cpp.

12517{
12518 for( Creature &critter : all_creatures() ) {
12519 if( pred( critter ) ) {
12520 return &critter;
12521 }
12522 }
12523 return nullptr;
12524}

References all_creatures().

◆ get_creatures_if()

std::vector< Creature * > game::get_creatures_if ( const std::function< bool(const Creature &)> &  pred)

Returns all creatures matching a predicate.

Only living ( not dead ) creatures are checked ( and returned ). Returned pointers are never null.

Definition at line 12426 of file game.cpp.

12428{
12429 std::vector<Creature *> result;
12430 for( Creature &critter : all_creatures() ) {
12431 if( pred( critter ) ) {
12432 result.push_back( &critter );
12433 }
12434 }
12435 return result;
12436}

References all_creatures().

◆ get_cur_om()

overmap & game::get_cur_om ( ) const

The overmap which contains the center submap of the reality bubble.

Definition at line 12406 of file game.cpp.

12407{
12408 // The player is located in the middle submap of the map.
12410 const tripoint pos_om = sm_to_om_copy( sm );
12411 // TODO: fix point types
12412 return overmap_buffer.get( point_abs_om( pos_om.xy() ) );
12413}
tripoint get_abs_sub() const
return abs_sub
Definition: map.cpp:8094
overmap & get(const point_abs_om &)
Uses overmap coordinates, that means x and y are directly compared with the position of the overmap.
point sm_to_om_copy(const point &p)
coords::coord_point< point, coords::origin::abs, coords::om > point_abs_om
Definition: coordinates.h:483
static constexpr int HALF_MAPSIZE
constexpr scale sm
Definition: coordinates.h:31

References overmapbuffer::get(), map::get_abs_sub(), HALF_MAPSIZE, m, overmap_buffer, coords::sm, sm_to_om_copy(), and tripoint::xy().

Referenced by start_game().

◆ get_dangerous_tile()

std::vector< std::string > game::get_dangerous_tile ( const tripoint dest_loc) const

Definition at line 9260 of file game.cpp.

9261{
9262 std::vector<std::string> harmful_stuff;
9263 const auto fields_here = m.field_at( u.pos() );
9264 for( const auto &e : m.field_at( dest_loc ) ) {
9265 // warn before moving into a dangerous field except when already standing within a similar field
9266 if( u.is_dangerous_field( e.second ) && fields_here.find_field( e.first ) == nullptr ) {
9267 harmful_stuff.push_back( e.second.name() );
9268 }
9269 }
9270
9271 if( !u.is_blind() ) {
9272 const trap &tr = m.tr_at( dest_loc );
9273 const bool boardable = static_cast<bool>( m.veh_at( dest_loc ).part_with_feature( "BOARDABLE",
9274 true ) );
9275 // HACK: Hack for now, later ledge should stop being a trap
9276 // Note: in non-z-level mode, ledges obey different rules and so should be handled as regular traps
9277 if( tr.loadid == tr_ledge && m.has_zlevels() ) {
9278 if( !boardable ) {
9279 harmful_stuff.emplace_back( tr.name() );
9280 }
9281 } else if( tr.can_see( dest_loc, u ) && !tr.is_benign() && !boardable ) {
9282 harmful_stuff.emplace_back( tr.name() );
9283 }
9284
9285 static const std::set< body_part > sharp_bps = {
9288 };
9289
9290 const auto sharp_bp_check = [this]( body_part bp ) {
9291 return u.immune_to( bp, { DT_CUT, 10 } );
9292 };
9293
9294 if( m.has_flag( "ROUGH", dest_loc ) && !m.has_flag( "ROUGH", u.pos() ) && !boardable &&
9295 ( u.get_armor_bash( bodypart_id( "foot_l" ) ) < 5 ||
9296 u.get_armor_bash( bodypart_id( "foot_r" ) ) < 5 ) ) {
9297 harmful_stuff.emplace_back( m.name( dest_loc ) );
9298 } else if( m.has_flag( "SHARP", dest_loc ) && !m.has_flag( "SHARP", u.pos() ) && !( u.in_vehicle ||
9299 m.veh_at( dest_loc ) ) &&
9300 u.dex_cur < 78 && !std::all_of( sharp_bps.begin(), sharp_bps.end(), sharp_bp_check ) ) {
9301 harmful_stuff.emplace_back( m.name( dest_loc ) );
9302 }
9303
9304 }
9305
9306 return harmful_stuff;
9307}
@ bp_foot_l
Definition: bodypart.h:50
@ bp_leg_r
Definition: bodypart.h:49
@ bp_eyes
Definition: bodypart.h:42
@ bp_hand_l
Definition: bodypart.h:46
@ bp_arm_l
Definition: bodypart.h:44
@ bp_leg_l
Definition: bodypart.h:48
@ bp_hand_r
Definition: bodypart.h:47
@ bp_head
Definition: bodypart.h:41
@ bp_torso
Definition: bodypart.h:40
@ bp_mouth
Definition: bodypart.h:43
@ bp_foot_r
Definition: bodypart.h:51
@ bp_arm_r
Definition: bodypart.h:45
int dex_cur
Definition: character.h:305
int get_armor_bash(bodypart_id bp) const override
Returns overall bashing resistance for the body_part.
Definition: character.cpp:6962
bool is_dangerous_field(const field_entry &entry) const
Returns true if the given field entry is dangerous to us.
Definition: creature.cpp:196
const field & field_at(const tripoint &p) const
Get the fields that are here.
Definition: map.cpp:5282
bool has_zlevels() const
Definition: map.h:1655
cata::optional< vpart_reference > part_with_feature(const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2481
bool immune_to(body_part bp, damage_unit dam) const
Check if a given body part is immune to a given damage type.
Definition: player.cpp:1075
@ DT_CUT
Definition: damage.h:25
Definition: trap.h:86
std::string name() const
Definition: trap.cpp:177
bool can_see(const tripoint &pos, const Character &p) const
Can player/npc p see this kind of trap, either by their memory (they known there is the trap) or by t...
Definition: trap.cpp:223
bool is_benign() const
If true, this is not really a trap and there won't be any safety queries before stepping onto it (e....
Definition: trap.h:159

References bp_arm_l, bp_arm_r, bp_eyes, bp_foot_l, bp_foot_r, bp_hand_l, bp_hand_r, bp_head, bp_leg_l, bp_leg_r, bp_mouth, bp_torso, trap::can_see(), Character::dex_cur, DT_CUT, map::field_at(), Character::get_armor_bash(), map::has_flag(), map::has_zlevels(), player::immune_to(), Character::in_vehicle, trap::is_benign(), Character::is_blind(), Creature::is_dangerous_field(), trap::loadid, m, trap::name(), map::name(), optional_vpart_position::part_with_feature(), Character::pos(), map::tr_at(), tr_ledge, u, and map::veh_at().

Referenced by is_dangerous_tile(), prompt_dangerous_tile(), and walk_move().

◆ get_fishable_locations()

std::unordered_set< tripoint > game::get_fishable_locations ( int  distance,
const tripoint fish_pos 
)

Get the contiguous fishable locations starting at fish_pos, out to the specificed distance.

Parameters
distanceDistance around the fish_pos to examine for contiguous fishable locations.
fish_posThe location being fished.
Returns
A set of locations representing the valid contiguous fishable locations.

Definition at line 3960 of file game.cpp.

3961{
3962 // We're going to get the contiguous fishable terrain starting at
3963 // the provided fishing location (e.g. where a line was cast or a fish
3964 // trap was set), and then check whether or not fishable monsters are
3965 // actually in those locations. This will help us ensure that we're
3966 // getting our fish from the location that we're ACTUALLY fishing,
3967 // rather than just somewhere in the vicinity.
3968
3969 std::unordered_set<tripoint> visited;
3970
3971 const tripoint fishing_boundary_min( fish_pos + point( -distance, -distance ) );
3972 const tripoint fishing_boundary_max( fish_pos + point( distance, distance ) );
3973
3974 const inclusive_cuboid<tripoint> fishing_boundaries(
3975 fishing_boundary_min, fishing_boundary_max );
3976
3977 const auto get_fishable_terrain = [&]( tripoint starting_point,
3978 std::unordered_set<tripoint> &fishable_terrain ) {
3979 std::queue<tripoint> to_check;
3980 to_check.push( starting_point );
3981 while( !to_check.empty() ) {
3982 const tripoint current_point = to_check.front();
3983 to_check.pop();
3984
3985 // We've been here before, so bail.
3986 if( visited.find( current_point ) != visited.end() ) {
3987 continue;
3988 }
3989
3990 // This point is out of bounds, so bail.
3991 if( !fishing_boundaries.contains( current_point ) ) {
3992 continue;
3993 }
3994
3995 // Mark this point as visited.
3996 visited.emplace( current_point );
3997
3998 if( m.has_flag( "FISHABLE", current_point ) ) {
3999 fishable_terrain.emplace( current_point );
4000 to_check.push( current_point + point_south );
4001 to_check.push( current_point + point_north );
4002 to_check.push( current_point + point_east );
4003 to_check.push( current_point + point_west );
4004 }
4005 }
4006 return;
4007 };
4008
4009 // Starting at the provided location, get our fishable terrain
4010 // and populate a set with those locations which we'll then use
4011 // to determine if any fishable monsters are in those locations.
4012 std::unordered_set<tripoint> fishable_points;
4013 get_fishable_terrain( fish_pos, fishable_points );
4014
4015 return fishable_points;
4016}
static constexpr point point_west
Definition: point.h:282
static constexpr point point_south
Definition: point.h:280
static constexpr point point_north
Definition: point.h:276
static constexpr point point_east
Definition: point.h:278

References inclusive_cuboid< Tripoint, >::contains(), map::has_flag(), m, point_east, point_north, point_south, and point_west.

◆ get_fishable_monsters()

std::vector< monster * > game::get_fishable_monsters ( std::unordered_set< tripoint > &  fishable_locations)

Get the fishable monsters within the provided fishable locations.

Parameters
fishable_locationsA set of locations which are valid fishable terrain. Any fishable monsters are filtered by this collection to determine those which can actually be caught.
Returns
Fishable monsters within the specified fishable terrain.

Definition at line 4018 of file game.cpp.

4020{
4021 std::vector<monster *> unique_fish;
4022 for( monster &critter : all_monsters() ) {
4023 // If it is fishable...
4024 if( critter.has_flag( MF_FISHABLE ) ) {
4025 const tripoint critter_pos = critter.pos();
4026 // ...and it is in a fishable location.
4027 if( fishable_locations.find( critter_pos ) != fishable_locations.end() ) {
4028 unique_fish.push_back( &critter );
4029 }
4030 }
4031 }
4032
4033 return unique_fish;
4034}
@ MF_FISHABLE
Definition: mtype.h:142

References all_monsters(), and MF_FISHABLE.

◆ get_follower_list()

std::set< character_id > game::get_follower_list ( )

Get set of followers.

Definition at line 2050 of file game.cpp.

2051{
2052 return follower_ids;
2053}

References follower_ids.

◆ get_kill_tracker()

const kill_tracker & game::get_kill_tracker ( ) const

Definition at line 966 of file game.cpp.

967{
968 return *kill_tracker_ptr;
969}

References kill_tracker_ptr.

Referenced by cleanup_at_end(), death_screen(), handle_action(), and win().

◆ get_levx()

int game::get_levx ( ) const

The top left corner of the reality bubble (in submaps coordinates).

This is the same as map::abs_sub of the m map.

Definition at line 12391 of file game.cpp.

12392{
12393 return m.get_abs_sub().x;
12394}

References map::get_abs_sub(), m, and tripoint::x.

Referenced by create_starting_npcs(), load_npcs(), look_around(), save_cyborg(), spawn_hallucination(), vertical_move(), and vertical_shift().

◆ get_levy()

int game::get_levy ( ) const

Definition at line 12396 of file game.cpp.

12397{
12398 return m.get_abs_sub().y;
12399}

References map::get_abs_sub(), m, and tripoint::y.

Referenced by create_starting_npcs(), load_npcs(), look_around(), save_cyborg(), spawn_hallucination(), vertical_move(), and vertical_shift().

◆ get_levz()

◆ get_moves_since_last_save()

int game::get_moves_since_last_save ( ) const

Definition at line 7359 of file game.cpp.

7360{
7361 return moves_since_last_save;
7362}

References moves_since_last_save.

◆ get_npcs_if()

std::vector< npc * > game::get_npcs_if ( const std::function< bool(const npc &)> &  pred)

Definition at line 12438 of file game.cpp.

12439{
12440 std::vector<npc *> result;
12441 for( npc &guy : all_npcs() ) {
12442 if( pred( guy ) ) {
12443 result.push_back( &guy );
12444 }
12445 }
12446 return result;
12447}

References all_npcs().

Referenced by allies(), chat(), and validate_npc_followers().

◆ get_player_base_save_path()

std::string game::get_player_base_save_path ( ) const

Base path for saving player data.

Just add a suffix (unique for the thing you want to save) and use the resulting path. Example: save_ui_data(get_player_base_save_path()+".ui")

Definition at line 12526 of file game.cpp.

12527{
12528 return get_world_base_save_path() + "/" + base64_encode( u.name );
12529}
std::string base64_encode(const std::string &str)
std::string get_world_base_save_path() const
Base path for saving world data.
Definition: game.cpp:12531

References base64_encode(), get_world_base_save_path(), Character::name, and u.

Referenced by save_player_data().

◆ get_player_input()

input_context game::get_player_input ( std::string &  action)
private

Definition at line 236 of file handle_action.cpp.

237{
238 input_context ctxt;
239 if( uquit == QUIT_WATCH ) {
240 ctxt = input_context( "DEFAULTMODE" );
241 ctxt.set_iso( true );
242 // The list of allowed actions in death-cam mode in game::handle_action
243 // *INDENT-OFF*
244 for( const action_id id : {
257 } ) {
258 ctxt.register_action( action_ident( id ) );
259 }
260 // *INDENT-ON*
261 ctxt.register_action( "QUIT", to_translation( "Accept your fate" ) );
262 } else {
264 }
265
267
268 user_turn current_turn;
269
270
271 // Checking early if we will need to handle animations
272 // If we do not need to handle animations that will not change as long as the user has not selected an action
273 // and we can handle it like we are not animating.
274 weather_printable wPrint;
275 bool animate_weather = false;
276 bool animate_sct = false;
277 bool do_animations = [&]() {
278 if( get_option<bool>( "ANIMATIONS" ) ) {
279 const bool weather_has_anim = init_weather_anim( get_weather().weather_id, wPrint );
280
281 animate_weather = weather_has_anim && get_option<bool>( "ANIMATION_RAIN" );
282 animate_sct = !SCT.vSCT.empty() && uquit != QUIT_WATCH && get_option<bool>( "ANIMATION_SCT" );
283
284#if defined(TILES)
285 // Always animate, minimap and terrain may have animations to run
286 return true;
287#else
288 // Otherwise we need to see if we actually should animate.
289 // Minimap and Terrain never animate in !TILES
290 return animate_weather || animate_sct || uquit == QUIT_WATCH;
291#endif
292 }
293 return false;
294 }
295 ();
296
297 if( do_animations ) {
298 ctxt.set_timeout( 125 );
299
301 make_shared_fast<game::draw_callback_t>( [&]() {
302 if( animate_weather ) {
303 draw_weather( wPrint );
304 }
305 if( animate_sct ) {
306 draw_sct();
307 }
308 } );
309 add_draw_callback( animation_cb );
310 invalidate_main_ui_adaptor(); // We want to redraw at least once.
311
312 do {
313 if( animate_weather ) {
315 generate_weather_anim_frame( get_weather().weather_id, wPrint );
316 }
317 // don't bother calculating SCT if we won't show it
318 if( animate_sct ) {
320
322
323 //Check for creatures on all drawing positions and offset if necessary
324 for( auto iter = SCT.vSCT.rbegin(); iter != SCT.vSCT.rend(); ++iter ) {
325 const direction oCurDir = iter->getDirecton();
326 const int width = utf8_width( iter->getText() );
327 for( int i = 0; i < width; ++i ) {
328 tripoint tmp( iter->getPosX() + i, iter->getPosY(), get_levz() );
329 const Creature *critter = critter_at( tmp, true );
330
331 if( critter != nullptr && u.sees( *critter ) ) {
332 i = -1;
333 int iPos = iter->getStep() + iter->getStepOffset();
334 for( auto iter2 = iter; iter2 != SCT.vSCT.rend(); ++iter2 ) {
335 if( iter2->getDirecton() == oCurDir &&
336 iter2->getStep() + iter2->getStepOffset() <= iPos ) {
337 if( iter2->getType() == "hp" ) {
338 iter2->advanceStepOffset();
339 }
340
341 iter2->advanceStepOffset();
342 iPos = iter2->getStep() + iter2->getStepOffset();
343 }
344 }
345 }
346 }
347 }
348
349 // Stop animation when done
350 animate_sct = !SCT.vSCT.empty();
351 }
352 // We don't cache these checks as their result may change after 1st redraw
354 // TODO: we redraw *everything* just to animate a couple blinking dots
355 // on the minimap or a few tiles.
356 // This is far from ideal, and can probably be done much cheaper
357 // (update only part of the screen? draw static parts into a texture?)
359 }
360
361 std::unique_ptr<static_popup> deathcam_msg_popup;
362 if( uquit == QUIT_WATCH ) {
363 deathcam_msg_popup = std::make_unique<static_popup>();
364 deathcam_msg_popup
365 ->wait_message( c_red, _( "Press %s to accept your fate…" ), ctxt.get_desc( "QUIT" ) )
366 .on_top( true );
367 }
368
370 } while( handle_mouseview( ctxt, action ) && uquit != QUIT_WATCH
371 && ( action != "TIMEOUT" || !current_turn.has_timeout_elapsed() ) );
372 ctxt.reset_timeout();
373 } else {
376 SCT.vSCT.clear();
377
378 ctxt.set_timeout( 125 );
379 while( handle_mouseview( ctxt, action ) ) {
380 if( action == "TIMEOUT" && current_turn.has_timeout_elapsed() ) {
381 break;
382 }
383 }
384 ctxt.reset_timeout();
385 }
386
387 return ctxt;
388}
std::string action_ident(action_id act)
Lookup a unique string identifier for a given action ID.
Definition: action.cpp:67
action_id
Enumerates all discrete actions that can be performed by player.
Definition: action.h:22
@ ACTION_CENTER
Center the viewport on character.
Definition: action.h:77
@ ACTION_SHIFT_SW
Move viewport south-west.
Definition: action.h:89
@ ACTION_SHIFT_NW
Move viewport north-west.
Definition: action.h:93
@ ACTION_KEYBINDINGS
Display keybindings list.
Definition: action.h:257
@ ACTION_SHIFT_E
Move viewport east.
Definition: action.h:83
@ ACTION_TOGGLE_MAP_MEMORY
Toggle memorized tiles being shown.
Definition: action.h:75
@ ACTION_SHIFT_S
Move viewport south.
Definition: action.h:87
@ ACTION_SHIFT_SE
Move viewport south-east.
Definition: action.h:85
@ ACTION_LOOK
Toggle look mode.
Definition: action.h:119
@ ACTION_SHIFT_NE
Move viewport north-east.
Definition: action.h:81
@ ACTION_SHIFT_W
Move viewport west.
Definition: action.h:91
@ ACTION_SHIFT_N
Move viewport north.
Definition: action.h:79
bool terrain_requires_animation()
Definition: animation.cpp:1136
bool minimap_requires_animation()
Definition: animation.cpp:1127
void draw_sct()
Definition: animation.cpp:797
void draw_weather(const weather_printable &wPrint)
Definition: animation.cpp:756
void add_draw_callback(shared_ptr_fast< draw_callback_t > cb)
Definition: game.cpp:3373
bool handle_mouseview(input_context &ctxt, std::string &action)
Definition: game.cpp:2312
void set_timeout(int val)
Sets input polling timeout as appropriate for the current interface system.
Definition: input.cpp:1458
std::string get_desc(const std::string &action_descriptor, unsigned int max_limit=0, const input_event_filter &evt_filter=allow_all_keys) const
Get a description text for the key/other input method associated with the given action.
Definition: input.cpp:756
void register_action(const std::string &action_descriptor)
Register an action with this input context.
Definition: input.cpp:676
void set_iso(bool mode=true)
Definition: input.cpp:1429
void reset_timeout()
Definition: input.cpp:1463
std::vector< cSCT > vSCT
Definition: output.h:947
void advanceAllSteps()
Definition: output.cpp:1924
bool has_timeout_elapsed()
input_context get_default_mode_input_context()
Definition: game.cpp:2412
static bool init_weather_anim(const weather_type_id &wtype, weather_printable &wPrint)
static void generate_weather_anim_frame(const weather_type_id &wtype, weather_printable &wPrint)
direction
Definition: line.h:39
scrollingcombattext SCT
Definition: output.cpp:65
Weather drawing tracking.
Definition: weather.h:59
translation to_translation(const std::string &raw)
Shorthands for translation::to_translation.

References _, action, ACTION_CENTER, action_ident(), ACTION_KEYBINDINGS, ACTION_LOOK, ACTION_SHIFT_E, ACTION_SHIFT_N, ACTION_SHIFT_NE, ACTION_SHIFT_NW, ACTION_SHIFT_S, ACTION_SHIFT_SE, ACTION_SHIFT_SW, ACTION_SHIFT_W, ACTION_TOGGLE_MAP_MEMORY, add_draw_callback(), scrollingcombattext::advanceAllSteps(), c_red, critter_at(), draw_sct(), draw_weather(), generate_weather_anim_frame(), get_default_mode_input_context(), input_context::get_desc(), get_levz(), get_weather, handle_mouseview(), user_turn::has_timeout_elapsed(), init_weather_anim(), invalidate_main_ui_adaptor(), m, minimap_requires_animation(), Character::posz(), QUIT_WATCH, ui_manager::redraw_invalidated(), input_context::register_action(), input_context::reset_timeout(), SCT, Character::sees(), input_context::set_iso(), input_context::set_timeout(), terrain_requires_animation(), to_translation(), u, map::update_visibility_cache(), uquit, utf8_width(), and scrollingcombattext::vSCT.

Referenced by handle_action().

◆ get_seed()

unsigned int game::get_seed ( ) const

Definition at line 1862 of file game.cpp.

1863{
1864 return seed;
1865}

References seed.

◆ get_user_action_counter()

int game::get_user_action_counter ( ) const

Definition at line 7364 of file game.cpp.

7365{
7366 return user_action_counter;
7367}

References user_action_counter.

◆ get_veh_dir_indicator_location()

cata::optional< tripoint > game::get_veh_dir_indicator_location ( bool  next) const

Returns the location where the indicator should go relative to the reality bubble, or nothing to indicate no indicator should be drawn.

Based on the vehicle the player is driving, if any.

Parameters
nextIf true, bases it on the vehicle the vehicle will turn to next turn, instead of the one it is currently facing.

Definition at line 3628 of file game.cpp.

3629{
3630 if( !get_option<bool>( "VEHICLE_DIR_INDICATOR" ) ) {
3631 return cata::nullopt;
3632 }
3633 const optional_vpart_position vp = m.veh_at( u.pos() );
3634 if( !vp ) {
3635 return cata::nullopt;
3636 }
3637 vehicle *const veh = &vp->vehicle();
3638 rl_vec2d face = next ? veh->dir_vec() : veh->face_vec();
3639 float r = 10.0;
3640 return tripoint( static_cast<int>( r * face.x ), static_cast<int>( r * face.y ), u.pos().z );
3641}
rl_vec2d dir_vec() const

References vehicle::dir_vec(), vehicle::face_vec(), m, cata::nullopt, Character::pos(), u, map::veh_at(), rl_vec2d::x, rl_vec2d::y, and tripoint::z.

Referenced by draw_veh_dir_indicator().

◆ get_world_base_save_path()

std::string game::get_world_base_save_path ( ) const

Base path for saving world data.

This yields a path to a folder.

Definition at line 12531 of file game.cpp.

12532{
12533 if( world_generator->active_world == nullptr ) {
12534 return PATH_INFO::savedir();
12535 }
12536 return world_generator->active_world->folder_path();
12537}
std::string savedir()
Definition: path_info.cpp:250

References PATH_INFO::savedir(), and world_generator.

Referenced by get_player_base_save_path(), load(), load_master(), move_save_to_graveyard(), save(), save_artifacts(), and save_factions_missions_npcs().

◆ get_zoom()

int game::get_zoom ( ) const

Definition at line 7350 of file game.cpp.

7351{
7352#if defined(TILES)
7353 return tileset_zoom;
7354#else
7355 return DEFAULT_TILESET_ZOOM;
7356#endif
7357}

References DEFAULT_TILESET_ZOOM, and tileset_zoom.

Referenced by look_around().

◆ grabbed_furn_move()

bool game::grabbed_furn_move ( const tripoint dp)
private
Strength determines ability to drag furniture

Definition at line 10063 of file game.cpp.

10064{
10065 // Furniture: pull, push, or standing still and nudging object around.
10066 // Can push furniture out of reach.
10067 tripoint fpos = u.pos() + u.grab_point;
10068 // supposed position of grabbed furniture
10069 if( !m.has_furn( fpos ) ) {
10070 // Where did it go? We're grabbing thin air so reset.
10071 add_msg( m_info, _( "No furniture at grabbed point." ) );
10072 u.grab( OBJECT_NONE );
10073 return false;
10074 }
10075
10076 const bool pushing_furniture = dp == u.grab_point;
10077 const bool pulling_furniture = dp == -u.grab_point;
10078 const bool shifting_furniture = !pushing_furniture && !pulling_furniture;
10079
10080 tripoint fdest = fpos + dp; // intended destination of furniture.
10081 // Check floor: floorless tiles don't need to be flat and have no traps
10082 const bool has_floor = m.has_floor( fdest );
10083 // Unfortunately, game::is_empty fails for tiles we're standing on,
10084 // which will forbid pulling, so:
10085 const bool canmove = (
10086 m.passable( fdest ) &&
10087 critter_at<npc>( fdest ) == nullptr &&
10088 critter_at<monster>( fdest ) == nullptr &&
10089 ( !pulling_furniture || is_empty( u.pos() + dp ) ) &&
10090 ( !has_floor || m.has_flag( "FLAT", fdest ) ) &&
10091 !m.has_furn( fdest ) &&
10092 !m.veh_at( fdest ) &&
10093 ( !has_floor || m.tr_at( fdest ).is_null() )
10094 );
10095
10096 const furn_t furntype = m.furn( fpos ).obj();
10097 const int src_items = m.i_at( fpos ).size();
10098 const int dst_items = m.i_at( fdest ).size();
10099
10100 const bool only_liquid_items = std::all_of( m.i_at( fdest ).begin(), m.i_at( fdest ).end(),
10101 [&]( item & liquid_item ) {
10102 return liquid_item.made_of( LIQUID );
10103 } );
10104
10105 const bool dst_item_ok = !m.has_flag( "NOITEM", fdest ) &&
10106 !m.has_flag( "SWIMMABLE", fdest ) &&
10107 !m.has_flag( "DESTROY_ITEM", fdest );
10108
10109 const bool src_item_ok = m.furn( fpos ).obj().has_flag( "CONTAINER" ) ||
10110 m.furn( fpos ).obj().has_flag( "FIRE_CONTAINER" ) ||
10111 m.furn( fpos ).obj().has_flag( "SEALED" );
10112
10113 const int fire_intensity = m.get_field_intensity( fpos, fd_fire );
10114 time_duration fire_age = m.get_field_age( fpos, fd_fire );
10115
10116 int str_req = furntype.move_str_req;
10117 // Factor in weight of items contained in the furniture.
10118 units::mass furniture_contents_weight = 0_gram;
10119 for( auto &contained_item : m.i_at( fpos ) ) {
10120 furniture_contents_weight += contained_item.weight();
10121 }
10122 str_req += furniture_contents_weight / 4_kilogram;
10123 if( !canmove ) {
10124 // TODO: What is something?
10125 add_msg( _( "The %s collides with something." ), furntype.name() );
10126 u.moves -= 50;
10127 return true;
10128 ///\EFFECT_STR determines ability to drag furniture
10129 } else if( str_req > u.get_str() &&
10130 one_in( std::max( 20 - str_req - u.get_str(), 2 ) ) ) {
10131 add_msg( m_bad, _( "You strain yourself trying to move the heavy %s!" ),
10132 furntype.name() );
10133 u.moves -= 100;
10134 u.mod_pain( 1 ); // Hurt ourselves.
10135 return true; // furniture and or obstacle wins.
10136 } else if( !src_item_ok && !only_liquid_items && dst_items > 0 ) {
10137 add_msg( _( "There's stuff in the way." ) );
10138 u.moves -= 50;
10139 return true;
10140 }
10141
10142 u.moves -= str_req * 10;
10143 // Additional penalty if we can't comfortably move it.
10144 if( str_req > u.get_str() ) {
10145 int move_penalty = std::pow( str_req, 2.0 ) + 100.0;
10146 if( move_penalty <= 1000 ) {
10147 if( u.get_str() >= str_req - 3 ) {
10148 u.moves -= std::max( 3000, move_penalty * 10 );
10149 add_msg( m_bad, _( "The %s is really heavy!" ), furntype.name() );
10150 if( one_in( 3 ) ) {
10151 add_msg( m_bad, _( "You fail to move the %s." ), furntype.name() );
10152 return true;
10153 }
10154 } else {
10155 u.moves -= 100;
10156 add_msg( m_bad, _( "The %s is too heavy for you to budge." ), furntype.name() );
10157 return true;
10158 }
10159 }
10160 u.moves -= move_penalty;
10161 if( move_penalty > 500 ) {
10162 add_msg( _( "Moving the heavy %s is taking a lot of time!" ),
10163 furntype.name() );
10164 } else if( move_penalty > 200 ) {
10165 if( one_in( 3 ) ) { // Nag only occasionally.
10166 add_msg( _( "It takes some time to move the heavy %s." ),
10167 furntype.name() );
10168 }
10169 }
10170 }
10172 _( "a scraping noise." ), true, "misc", "scraping" );
10173
10175 ( tripoint_abs_ms( m.getabs( fpos ) ) );
10176
10177 // Actually move the furniture.
10178 m.furn_set( fdest, m.furn( fpos ), atd ? atd->clone() : nullptr );
10179 m.furn_set( fpos, f_null );
10180
10181 if( fire_intensity == 1 && !pulling_furniture ) {
10182 m.remove_field( fpos, fd_fire );
10183 m.set_field_intensity( fdest, fd_fire, fire_intensity );
10184 m.set_field_age( fdest, fd_fire, fire_age );
10185 }
10186
10187 // Is there is only liquids on the ground, remove them after moving furniture.
10188 if( dst_items > 0 && only_liquid_items ) {
10189 m.i_clear( fdest );
10190 }
10191
10192 if( src_items > 0 ) { // Move the stuff inside.
10193 if( dst_item_ok && src_item_ok ) {
10194 // Assume contents of both cells are legal, so we can just swap contents.
10195 std::list<item> temp;
10196 std::move( m.i_at( fpos ).begin(), m.i_at( fpos ).end(),
10197 std::back_inserter( temp ) );
10198 m.i_clear( fpos );
10199 for( auto item_iter = m.i_at( fdest ).begin();
10200 item_iter != m.i_at( fdest ).end(); ++item_iter ) {
10201 m.i_at( fpos ).insert( *item_iter );
10202 }
10203 m.i_clear( fdest );
10204 for( auto &cur_item : temp ) {
10205 m.i_at( fdest ).insert( cur_item );
10206 }
10207 } else {
10208 add_msg( _( "Stuff spills from the %s!" ), furntype.name() );
10209 }
10210 }
10211
10212 if( shifting_furniture ) {
10213 // We didn't move
10214 tripoint d_sum = u.grab_point + dp;
10215 if( std::abs( d_sum.x ) < 2 && std::abs( d_sum.y ) < 2 ) {
10216 u.grab_point = d_sum; // furniture moved relative to us
10217 } else { // we pushed furniture out of reach
10218 add_msg( _( "You let go of the %s." ), furntype.name() );
10219 u.grab( OBJECT_NONE );
10220 }
10221 return true; // We moved furniture but stayed still.
10222 }
10223
10224 if( pushing_furniture && m.impassable( fpos ) ) {
10225 // Not sure how that chair got into a wall, but don't let player follow.
10226 add_msg( _( "You let go of the %1$s as it slides past %2$s." ),
10227 furntype.name(), m.tername( fdest ) );
10228 u.grab( OBJECT_NONE );
10229 return true;
10230 }
10231
10232 return false;
10233}
virtual int get_str() const
Getters for stats exclusive to characters.
Definition: character.cpp:4057
virtual active_tile_data * clone() const =0
void grab(object_type grab_type, const tripoint &grab_point=tripoint_zero)
Definition: avatar.cpp:639
bool is_empty(const tripoint &p)
Returns true if there is no player, NPC, or monster on the tile and move_cost > 0.
Definition: game.cpp:5140
void insert(const item &newitem) override
Definition: map.cpp:152
void remove_field(const tripoint &p, const field_type_id &field_to_remove)
Remove field entry at xy, ignored if the field entry is not present.
Definition: map.cpp:5448
time_duration set_field_age(const tripoint &p, const field_type_id &type, const time_duration &age, bool isoffset=false)
Set age of field entry at point.
Definition: map.cpp:5322
time_duration get_field_age(const tripoint &p, const field_type_id &type) const
Get the age of a field entry (field_entry::age), if there is no field of that type,...
Definition: map.cpp:5356
int get_field_intensity(const tripoint &p, const field_type_id &type) const
Get the intensity of a field entry (field_entry::intensity), if there is no field of that type,...
Definition: map.cpp:5362
int set_field_intensity(const tripoint &p, const field_type_id &type, int new_intensity, bool isoffset=false)
Set intensity of field entry at point, creating if not present, removing if intensity becomes 0.
Definition: map.cpp:5335
std::string tername(const tripoint &p) const
Definition: map.cpp:1703
void i_clear(const tripoint &p)
Definition: map.cpp:4106
void furn_set(const tripoint &p, const furn_id &new_furniture, cata::poly_serialized< active_tile_data > new_active=nullptr)
Sets the furniture at given position.
Definition: map.cpp:1354
bool has_floor(const tripoint &p) const
Definition: map.cpp:2001
tripoint grab_point
Definition: player.h:683
coords::coord_point< tripoint, coords::origin::abs, coords::ms > tripoint_abs_ms
Definition: coordinates.h:486
@ OBJECT_NONE
Definition: enums.h:187
field_type_id fd_fire
Definition: field_type.cpp:345
furn_id f_null
Definition: mapdata.cpp:1095
template active_tile_data * furn_at< active_tile_data >(const tripoint_abs_ms &)
bool move(avatar &you, map &m, const tripoint &d)
void sound(const tripoint &p, int vol, sound_t category, const std::string &description, bool ambient=false, const std::string &id="", const std::string &variant="default")
Sound at (p) of intensity (vol)
Definition: sounds.cpp:177
int move_str_req
Definition: mapdata.h:505
bool has_flag(const std::string &flag) const
Definition: mapdata.h:415

References _, add_msg(), item_stack::begin(), active_tile_data::clone(), item_stack::end(), f_null, fd_fire, map::furn(), active_tiles::furn_at< active_tile_data >(), map::furn_set(), map::get_field_age(), map::get_field_intensity(), Character::get_str(), map::getabs(), avatar::grab(), player::grab_point, map_data_common_t::has_flag(), map::has_flag(), map::has_floor(), map::has_furn(), map::i_at(), map::i_clear(), map::impassable(), map_stack::insert(), is_empty(), trap::is_null(), m, m_bad, m_info, player::mod_pain(), avatar_action::move(), furn_t::move_str_req, sounds::movement, Creature::moves, map_data_common_t::name(), int_id< T >::obj(), OBJECT_NONE, one_in(), map::passable(), Character::pos(), map::remove_field(), map::set_field_age(), map::set_field_intensity(), item_stack::size(), sounds::sound(), map::tername(), map::tr_at(), u, map::veh_at(), tripoint::x, and tripoint::y.

Referenced by grabbed_move().

◆ grabbed_move()

bool game::grabbed_move ( const tripoint dp)
private

Check for dangerous stuff at dest_loc, return false if the player decides not to step there.

Definition at line 10235 of file game.cpp.

10236{
10237 if( u.get_grab_type() == OBJECT_NONE ) {
10238 return false;
10239 }
10240
10241 if( dp.z != 0 ) {
10242 // No dragging stuff up/down stairs yet!
10243 return false;
10244 }
10245
10246 // vehicle: pulling, pushing, or moving around the grabbed object.
10247 if( u.get_grab_type() == OBJECT_VEHICLE ) {
10248 return grabbed_veh_move( dp );
10249 }
10250
10251 if( u.get_grab_type() == OBJECT_FURNITURE ) {
10252 return grabbed_furn_move( dp );
10253 }
10254
10255 add_msg( m_info, _( "Nothing at grabbed point %d,%d,%d or bad grabbed object type." ),
10257 u.grab( OBJECT_NONE );
10258 return false;
10259}
object_type get_grab_type() const
Definition: avatar.cpp:647
bool grabbed_furn_move(const tripoint &dp)
Definition: game.cpp:10063
bool grabbed_veh_move(const tripoint &dp)
Definition: grab.cpp:21
@ OBJECT_FURNITURE
Definition: enums.h:197
@ OBJECT_VEHICLE
Definition: enums.h:193

References _, add_msg(), avatar::get_grab_type(), avatar::grab(), player::grab_point, grabbed_furn_move(), grabbed_veh_move(), m_info, OBJECT_FURNITURE, OBJECT_NONE, OBJECT_VEHICLE, u, tripoint::x, tripoint::y, and tripoint::z.

Referenced by walk_move().

◆ grabbed_veh_move()

bool game::grabbed_veh_move ( const tripoint dp)
private
Strength determines ability to drag vehicles Strength increases speed of dragging vehicles

Definition at line 21 of file grab.cpp.

22{
23 const optional_vpart_position grabbed_vehicle_vp = m.veh_at( u.pos() + u.grab_point );
24 if( !grabbed_vehicle_vp ) {
25 add_msg( m_info, _( "No vehicle at grabbed point." ) );
27 return false;
28 }
29 vehicle *grabbed_vehicle = &grabbed_vehicle_vp->vehicle();
30 if( !grabbed_vehicle ||
31 !grabbed_vehicle->handle_potential_theft( dynamic_cast<player &>( g->u ) ) ) {
32 return false;
33 }
34 const int grabbed_part = grabbed_vehicle_vp->part_index();
35 for( int part_index = 0; part_index < grabbed_vehicle->part_count(); ++part_index ) {
36 monster *mon = grabbed_vehicle->get_pet( part_index );
37 if( mon != nullptr && mon->has_effect( effect_harnessed ) ) {
38 add_msg( m_info, _( "You cannot move this vehicle whilst your %s is harnessed!" ),
39 mon->get_name() );
41 return false;
42 }
43 }
44 const vehicle *veh_under_player = veh_pointer_or_null( m.veh_at( u.pos() ) );
45 if( grabbed_vehicle == veh_under_player ) {
46 u.grab_point = -dp;
47 return false;
48 }
49
50 tripoint dp_veh = -u.grab_point;
51 const tripoint prev_grab = u.grab_point;
52 tripoint next_grab = u.grab_point;
53
54 bool zigzag = false;
55
56 if( dp == prev_grab ) {
57 // We are pushing in the direction of vehicle
58 dp_veh = dp;
59 } else if( std::abs( dp.x + dp_veh.x ) != 2 && std::abs( dp.y + dp_veh.y ) != 2 ) {
60 // Not actually moving the vehicle, don't do the checks
61 u.grab_point = -( dp + dp_veh );
62 return false;
63 } else if( ( dp.x == prev_grab.x || dp.y == prev_grab.y ) &&
64 next_grab.x != 0 && next_grab.y != 0 ) {
65 // Zig-zag (or semi-zig-zag) pull: player is diagonal to vehicle
66 // and moves away from it, but not directly away
67 dp_veh.x = dp.x == -dp_veh.x ? 0 : dp_veh.x;
68 dp_veh.y = dp.y == -dp_veh.y ? 0 : dp_veh.y;
69
70 next_grab = -dp_veh;
71 zigzag = true;
72 } else {
73 // We are pulling the vehicle
74 next_grab = -dp;
75 }
76
77 // Make sure the mass and pivot point are correct
78 grabbed_vehicle->invalidate_mass();
79
80 //vehicle movement: strength check
81 int mc = 0;
82 int str_req = grabbed_vehicle->total_mass() / 25_kilogram; //strength required to move vehicle.
83
84 //if vehicle is rollable we modify str_req based on a function of movecost per wheel.
85
86 // Vehicle just too big to grab & move; 41-45 lets folks have a bit of a window
87 // (Roughly 1.1K kg = danger zone; cube vans are about the max)
88 if( str_req > 45 ) {
89 add_msg( m_info, _( "The %s is too bulky for you to move by hand." ),
90 grabbed_vehicle->name );
91 return true; // No shoving around an RV.
92 }
93
94 const auto &wheel_indices = grabbed_vehicle->wheelcache;
95 if( grabbed_vehicle->valid_wheel_config() ) {
96 //determine movecost for terrain touching wheels
97 const tripoint vehpos = grabbed_vehicle->global_pos3();
98 for( int p : wheel_indices ) {
99 const tripoint wheel_pos = vehpos + grabbed_vehicle->part( p ).precalc[0];
100 const int mapcost = m.move_cost( wheel_pos, grabbed_vehicle );
101 mc += str_req / wheel_indices.size() * mapcost;
102 }
103 //set strength check threshold
104 //if vehicle has many or only one wheel (shopping cart), it is as if it had four.
105 if( wheel_indices.size() > 4 || wheel_indices.size() == 1 ) {
106 str_req = mc / 4 + 1;
107 } else {
108 str_req = mc / wheel_indices.size() + 1;
109 }
110 } else {
111 str_req++;
112 //if vehicle has no wheels str_req make a noise.
113 if( str_req <= u.get_str() ) {
114 sounds::sound( grabbed_vehicle->global_pos3(), str_req * 2, sounds::sound_t::movement,
115 _( "a scraping noise." ), true, "misc", "scraping" );
116 }
117 }
118
119 //final strength check and outcomes
120 ///\EFFECT_STR determines ability to drag vehicles
121 if( str_req <= u.get_str() ) {
122 //calculate exertion factor and movement penalty
123 ///\EFFECT_STR increases speed of dragging vehicles
124 u.moves -= 100 * str_req / std::max( 1, u.get_str() );
125 const int ex = dice( 1, 3 ) - 1 + str_req;
126 if( ex > u.get_str() + 1 ) {
127 // Pain and movement penalty if exertion exceeds character strength
128 add_msg( m_bad, _( "You strain yourself to move the %s!" ), grabbed_vehicle->name );
129 u.moves -= 200;
130 u.mod_pain( 1 );
131 } else if( ex >= u.get_str() ) {
132 // Movement is slow if exertion nearly equals character strength
133 add_msg( _( "It takes some time to move the %s." ), grabbed_vehicle->name );
134 u.moves -= 200;
135 }
136 } else {
137 u.moves -= 100;
138 add_msg( m_bad, _( "You lack the strength to move the %s" ), grabbed_vehicle->name );
139 return true;
140 }
141
142 std::string blocker_name = _( "errors in movement code" );
143 const auto get_move_dir = [&]( const tripoint & dir, const tripoint & from ) {
144 tileray mdir;
145
146 mdir.init( dir.xy() );
147 grabbed_vehicle->turn( mdir.dir() - grabbed_vehicle->face.dir() );
148 grabbed_vehicle->face = grabbed_vehicle->turn_dir;
149 grabbed_vehicle->precalc_mounts( 1, mdir.dir(), grabbed_vehicle->pivot_point() );
150 grabbed_vehicle->adjust_zlevel( 1, dp );
151
152 // Grabbed part has to stay at distance 1 to the player
153 // and in roughly the same direction.
154 const tripoint new_part_pos = grabbed_vehicle->global_pos3() +
155 grabbed_vehicle->part( grabbed_part ).precalc[ 1 ];
156 const tripoint expected_pos = u.pos() + dp + from;
157 const tripoint actual_dir = expected_pos - new_part_pos;
158
159 // Set player location to illegal value so it can't collide with vehicle.
160 const tripoint player_prev = u.pos();
162 std::vector<veh_collision> colls;
163 const bool failed = grabbed_vehicle->collision( colls, actual_dir, true );
164 u.setpos( player_prev );
165 if( !colls.empty() ) {
166 blocker_name = colls.front().target_name;
167 }
168 return failed ? tripoint_zero : actual_dir;
169 };
170
171 // First try the move as intended
172 // But if that fails and the move is a zig-zag, try to recover:
173 // Try to place the vehicle in the position player just left rather than "flattening" the zig-zag
174 tripoint final_dp_veh = get_move_dir( dp_veh, next_grab );
175 if( final_dp_veh == tripoint_zero && zigzag ) {
176 final_dp_veh = get_move_dir( -prev_grab, -dp );
177 next_grab = -dp;
178 }
179
180 if( final_dp_veh == tripoint_zero ) {
181 add_msg( _( "The %s collides with %s." ), grabbed_vehicle->name, blocker_name );
182 u.grab_point = prev_grab;
183 return true;
184 }
185
186 u.grab_point = next_grab;
187
188 m.displace_vehicle( *grabbed_vehicle, final_dp_veh );
189
190 if( grabbed_vehicle ) {
191 grabbed_vehicle->shift_zlevel();
192 grabbed_vehicle->check_falling_or_floating();
193 } else {
194 debugmsg( "Grabbed vehicle disappeared" );
195 return false;
196 }
197
198 for( int p : wheel_indices ) {
199 if( one_in( 2 ) ) {
200 tripoint wheel_p = grabbed_vehicle->global_part_pos3( grabbed_part );
201 grabbed_vehicle->handle_trap( wheel_p, p );
202 }
203 }
204
205 return false;
206
207}
bool displace_vehicle(vehicle &veh, const tripoint &dp)
Definition: map.cpp:1113
int move_cost(const tripoint &p, const vehicle *ignored_vehicle=nullptr) const
Calculate the cost to move past the tile at p.
Definition: map.cpp:1774
units::angle dir() const
Definition: tileray.cpp:74
void init(const point &ad)
Definition: tileray.cpp:27
void turn(units::angle deg)
const point & pivot_point() const
Definition: vehicle.cpp:5649
void adjust_zlevel(int idir=0, const tripoint &offset=tripoint_zero)
tripoint global_pos3() const
Definition: vehicle.cpp:3104
void precalc_mounts(int idir, units::angle dir, const point &pivot)
Definition: vehicle.cpp:3026
bool valid_wheel_config() const
Definition: vehicle.cpp:4282
units::mass total_mass() const
Definition: vehicle.cpp:3129
std::vector< int > wheelcache
Definition: vehicle.h:1799
void check_falling_or_floating()
tileray face
Definition: vehicle.h:1929
void invalidate_mass()
Mark mass caches and pivot cache as dirty.
Definition: vehicle.cpp:6791
int part_count() const
Definition: vehicle.cpp:6898
bool collision(std::vector< veh_collision > &colls, const tripoint &dp, bool just_detect, bool bash_floor=false)
monster * get_pet(int p) const
Definition: vehicle.cpp:3085
vehicle_part & part(int part_num)
Definition: vehicle.cpp:6903
void handle_trap(const tripoint &p, int part)
tripoint global_part_pos3(const int &index) const
Get the coordinates of the studied part of the vehicle.
Definition: vehicle.cpp:3109
void shift_zlevel()
units::angle turn_dir
Definition: vehicle.h:1908
static const efftype_id effect_harnessed("harnessed")
static constexpr tripoint tripoint_zero
Definition: point.h:273
int dice(int number, int sides)
Definition: rng.cpp:85
std::array< tripoint, 2 > precalc
mount translated to face.dir [0] and turn_dir [1]
Definition: vehicle.h:371

References _, add_msg(), vehicle::adjust_zlevel(), vehicle::check_falling_or_floating(), vehicle::collision(), debugmsg, dice(), tileray::dir(), map::displace_vehicle(), effect_harnessed, vehicle::face, failed, g, monster::get_name(), vehicle::get_pet(), Character::get_str(), vehicle::global_part_pos3(), vehicle::global_pos3(), avatar::grab(), player::grab_point, vehicle::handle_potential_theft(), vehicle::handle_trap(), Creature::has_effect(), tileray::init(), vehicle::invalidate_mass(), m, m_bad, m_info, player::mod_pain(), map::move_cost(), sounds::movement, Creature::moves, vehicle::name, OBJECT_NONE, one_in(), vehicle::part(), vehicle::part_count(), vehicle::pivot_point(), Character::pos(), vehicle_part::precalc, vehicle::precalc_mounts(), Character::setpos(), vehicle::shift_zlevel(), sounds::sound(), vehicle::total_mass(), tripoint_zero, vehicle::turn(), vehicle::turn_dir, u, vehicle::valid_wheel_config(), map::veh_at(), veh_pointer_or_null(), vehicle::wheelcache, tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by grabbed_move().

◆ handle_action()

bool game::handle_action ( )
private

Definition at line 1512 of file handle_action.cpp.

1513{
1514 std::string action;
1515 input_context ctxt;
1517 user_turn current_turn;
1518 // Check if we have an auto-move destination
1519 if( u.has_destination() ) {
1521 if( act == ACTION_NULL ) {
1522 add_msg( m_info, _( "Auto-move canceled" ) );
1524 return false;
1525 }
1526 } else if( u.has_destination_activity() ) {
1527 // starts destination activity after the player successfully reached his destination
1529 return false;
1530 } else {
1531 // No auto-move, ask player for input
1532 ctxt = get_player_input( action );
1533 }
1534
1535 const optional_vpart_position vp = m.veh_at( u.pos() );
1536 bool veh_ctrl = !u.is_dead_state() &&
1537 ( ( vp && vp->vehicle().player_in_control( u ) ) || remoteveh() != nullptr );
1538
1539 // If performing an action with right mouse button, co-ordinates
1540 // of location clicked.
1541 cata::optional<tripoint> mouse_target;
1542
1543 if( uquit == QUIT_WATCH && action == "QUIT" ) {
1544 uquit = QUIT_DIED;
1545 return false;
1546 }
1547
1548 if( act == ACTION_NULL ) {
1550
1551 if( act == ACTION_KEYBINDINGS ) {
1552 // already handled by input context
1553 return false;
1554 }
1555
1556 if( act == ACTION_MAIN_MENU ) {
1557 if( uquit == QUIT_WATCH ) {
1558 return false;
1559 }
1560 // No auto-move actions have or can be set at this point.
1562 destination_preview.clear();
1564 if( act == ACTION_NULL ) {
1565 return false;
1566 }
1567 }
1568
1569 if( act == ACTION_ACTIONMENU ) {
1570 if( uquit == QUIT_WATCH ) {
1571 return false;
1572 }
1573 // No auto-move actions have or can be set at this point.
1575 destination_preview.clear();
1577 if( act == ACTION_NULL ) {
1578 return false;
1579 }
1580#if defined(__ANDROID__)
1581 if( get_option<bool>( "ANDROID_ACTIONMENU_AUTOADD" ) && ctxt.get_category() == "DEFAULTMODE" ) {
1582 add_best_key_for_action_to_quick_shortcuts( act, ctxt.get_category(), false );
1583 }
1584#endif
1585 }
1586
1587 if( act == ACTION_KEYBINDINGS ) {
1589 destination_preview.clear();
1590 act = ctxt.display_menu( true );
1591 if( act == ACTION_NULL ) {
1592 return false;
1593 }
1594 }
1595
1598 }
1599
1600 if( act == ACTION_SELECT || act == ACTION_SEC_SELECT ) {
1601 // Mouse button click
1602 if( veh_ctrl ) {
1603 // No mouse use in vehicle
1604 return false;
1605 }
1606
1607 if( u.is_dead_state() ) {
1608 // do not allow mouse actions while dead
1609 return false;
1610 }
1611
1612 const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
1613 if( !mouse_pos ) {
1614 return false;
1615 } else if( !u.sees( *mouse_pos ) ) {
1616 // Not clicked in visible terrain
1617 return false;
1618 }
1619 mouse_target = mouse_pos;
1620
1621 if( act == ACTION_SELECT ) {
1622 // Note: The following has the potential side effect of
1623 // setting auto-move destination state in addition to setting
1624 // act.
1625 if( !try_get_left_click_action( act, *mouse_target ) ) {
1626 return false;
1627 }
1628 } else if( act == ACTION_SEC_SELECT ) {
1629 if( !try_get_right_click_action( act, *mouse_target ) ) {
1630 return false;
1631 }
1632 }
1633 } else if( act != ACTION_TIMEOUT ) {
1634 // act has not been set for an auto-move, so clearing possible
1635 // auto-move destinations. Since initializing an auto-move with
1636 // the mouse may span across multiple actions, we do not clear the
1637 // auto-move destination if the action is only a timeout, as this
1638 // would require the user to double click quicker than the
1639 // timeout delay.
1641 destination_preview.clear();
1642 }
1643 }
1644
1645 if( act == ACTION_NULL ) {
1646 const input_event &&evt = ctxt.get_raw_input();
1647 if( !evt.sequence.empty() ) {
1648 const int ch = evt.get_first_input();
1649 const std::string &&name = inp_mngr.get_keyname( ch, evt.type, true );
1650 if( !get_option<bool>( "NO_UNKNOWN_COMMAND_MSG" ) ) {
1651 add_msg( m_info, _( "Unknown command: \"%s\" (%ld)" ), name, ch );
1652 if( const cata::optional<std::string> hint =
1654 add_msg( m_info, _( "%s at any time to see and edit keybindings relevant to "
1655 "the current context." ),
1656 *hint );
1657 }
1658 }
1659 }
1660 return false;
1661 }
1662
1663 // This has no action unless we're in a special game mode.
1664 gamemode->pre_action( act );
1665
1666 int soffset = get_option<int>( "MOVE_VIEW_OFFSET" );
1667
1668 int before_action_moves = u.moves;
1669
1670 // These actions are allowed while deathcam is active. Registered in game::get_player_input
1671 if( uquit == QUIT_WATCH || !u.is_dead_state() ) {
1672 switch( act ) {
1675 break;
1676
1677 case ACTION_CENTER:
1680 break;
1681
1682 case ACTION_SHIFT_N:
1683 case ACTION_SHIFT_NE:
1684 case ACTION_SHIFT_E:
1685 case ACTION_SHIFT_SE:
1686 case ACTION_SHIFT_S:
1687 case ACTION_SHIFT_SW:
1688 case ACTION_SHIFT_W:
1689 case ACTION_SHIFT_NW: {
1690 static const std::map<action_id, std::pair<point, point>> shift_delta = {
1699 };
1701 shift_delta.at( act ).second * soffset : shift_delta.at( act ).first * soffset;
1702 }
1703 break;
1704
1705 case ACTION_LOOK:
1706 look_around();
1707 break;
1708
1709 case ACTION_KEYBINDINGS:
1710 // already handled by input context
1711 break;
1712
1713 default:
1714 break;
1715 }
1716 }
1717
1718 // actions allowed only while alive
1719 if( !u.is_dead_state() ) {
1720 switch( act ) {
1721 case ACTION_NULL:
1722 case NUM_ACTIONS:
1723 break; // dummy entries
1724 case ACTION_ACTIONMENU:
1725 case ACTION_MAIN_MENU:
1726 case ACTION_KEYBINDINGS:
1727 break; // handled above
1728
1729 case ACTION_TIMEOUT:
1730 if( check_safe_mode_allowed( false ) ) {
1731 u.pause();
1732 }
1733 break;
1734
1735 case ACTION_PAUSE:
1736 if( check_safe_mode_allowed() ) {
1737 u.pause();
1738 }
1739 break;
1740
1741 case ACTION_CYCLE_MOVE:
1743 break;
1744
1745 case ACTION_RESET_MOVE:
1747 break;
1748
1749 case ACTION_TOGGLE_RUN:
1751 break;
1752
1755 break;
1756
1759 break;
1760
1761 case ACTION_MOVE_FORTH:
1763 case ACTION_MOVE_RIGHT:
1765 case ACTION_MOVE_BACK:
1767 case ACTION_MOVE_LEFT:
1769 if( !u.get_value( "remote_controlling" ).empty() &&
1773 } else if( veh_ctrl ) {
1774 // vehicle control uses x for steering and y for ac/deceleration,
1775 // so no rotation needed
1777 } else {
1779 if( auto_travel_mode && !u.is_auto_moving() ) {
1780 for( int i = 0; i < SEEX; i++ ) {
1781 tripoint auto_travel_destination( u.posx() + dest_delta.x * ( SEEX - i ),
1782 u.posy() + dest_delta.y * ( SEEX - i ),
1783 u.posz() );
1785 auto_travel_destination,
1787 u.get_path_avoid() );
1788 if( !destination_preview.empty() ) {
1791 break;
1792 }
1793 }
1796 if( dest_next == point_zero ) {
1798 }
1799 dest_delta = dest_next;
1800 }
1801 if( !avatar_action::move( u, m, dest_delta ) ) {
1802 // auto-move should be canceled due to a failed move or obstacle
1804 }
1805 }
1806 break;
1807 case ACTION_MOVE_DOWN:
1808 if( u.is_mounted() ) {
1809 auto mon = u.mounted_creature.get();
1810 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1811 add_msg( m_info, _( "You can't go down stairs while you're riding." ) );
1812 break;
1813 }
1814 }
1815 if( !u.in_vehicle ) {
1816 vertical_move( -1, false );
1817 } else if( veh_ctrl && vp->vehicle().is_rotorcraft() ) {
1819 }
1820 break;
1821
1822 case ACTION_MOVE_UP:
1823 if( u.is_mounted() ) {
1824 auto mon = u.mounted_creature.get();
1825 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1826 add_msg( m_info, _( "You can't go down stairs while you're riding." ) );
1827 break;
1828 }
1829 }
1830 if( !u.in_vehicle ) {
1831 vertical_move( 1, false );
1832 } else if( veh_ctrl && vp->vehicle().is_rotorcraft() ) {
1834 } else if( veh_ctrl && vp->vehicle().has_part( "ROTOR" ) &&
1835 !vp->vehicle().has_sufficient_rotorlift() ) {
1836 add_msg( m_bad, _( "The rotors struggle to generate enough lift!" ) );
1837 }
1838 break;
1839
1840 case ACTION_OPEN:
1842 add_msg( m_info, _( "You can't open things while you're in your shell." ) );
1843 } else if( u.is_mounted() ) {
1844 add_msg( m_info, _( "You can't open things while you're riding." ) );
1845 } else {
1846 open();
1847 }
1848 break;
1849
1850 case ACTION_CLOSE:
1852 add_msg( m_info, _( "You can't close things while you're in your shell." ) );
1853 } else if( u.is_mounted() ) {
1854 auto mon = u.mounted_creature.get();
1855 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1856 add_msg( m_info, _( "You can't close things while you're riding." ) );
1857 }
1858 } else if( mouse_target ) {
1859 doors::close_door( m, u, *mouse_target );
1860 } else {
1861 close();
1862 }
1863 break;
1864
1865 case ACTION_SMASH:
1866 if( veh_ctrl ) {
1867 handbrake();
1868 } else if( u.has_active_mutation( trait_SHELL2 ) ) {
1869 add_msg( m_info, _( "You can't smash things while you're in your shell." ) );
1870 } else {
1871 smash();
1872 }
1873 break;
1874
1875 case ACTION_EXAMINE:
1877 add_msg( m_info, _( "You can't examine your surroundings while you're in your shell." ) );
1878 } else if( mouse_target ) {
1879 examine( *mouse_target );
1880 } else {
1881 examine();
1882 }
1883 break;
1884
1885 case ACTION_ADVANCEDINV:
1887 add_msg( m_info, _( "You can't move mass quantities while you're in your shell." ) );
1888 } else if( u.is_mounted() ) {
1889 add_msg( m_info, _( "You can't move mass quantities while you're riding." ) );
1890 } else {
1892 }
1893 break;
1894
1895 case ACTION_PICKUP:
1897 add_msg( m_info, _( "You can't pick anything up while you're in your shell." ) );
1898 } else if( u.is_mounted() ) {
1899 add_msg( m_info, _( "You can't pick anything up while you're riding." ) );
1900 } else if( mouse_target ) {
1901 pickup( *mouse_target );
1902 } else {
1903 pickup();
1904 }
1905 break;
1906
1907 case ACTION_PICKUP_FEET:
1909 add_msg( m_info, _( "You can't pick anything up while you're in your shell." ) );
1910 } else {
1911 pickup_feet();
1912 }
1913 break;
1914
1915 case ACTION_GRAB:
1917 add_msg( m_info, _( "You can't grab things while you're in your shell." ) );
1918 } else if( u.is_mounted() ) {
1919 add_msg( m_info, _( "You can't grab things while you're riding." ) );
1920 } else {
1921 grab();
1922 }
1923 break;
1924
1925 case ACTION_HAUL:
1927 add_msg( m_info, _( "You can't haul things while you're in your shell." ) );
1928 } else if( u.is_mounted() ) {
1929 add_msg( m_info, _( "You can't haul things while you're riding." ) );
1930 } else {
1931 haul();
1932 }
1933 break;
1934
1935 case ACTION_BUTCHER:
1937 add_msg( m_info, _( "You can't butcher while you're in your shell." ) );
1938 } else if( u.is_mounted() ) {
1939 add_msg( m_info, _( "You can't butcher while you're riding." ) );
1940 } else {
1941 butcher();
1942 }
1943 break;
1944
1945 case ACTION_CHAT:
1946 chat();
1947 break;
1948
1949 case ACTION_PEEK:
1951 add_msg( m_info, _( "You can't peek around corners while you're in your shell." ) );
1952 } else if( u.is_mounted() ) {
1953 add_msg( m_info, _( "You can't peek around corners while you're riding." ) );
1954 } else {
1955 peek();
1956 }
1957 break;
1958
1959 case ACTION_LIST_ITEMS:
1961 break;
1962
1963 case ACTION_ZONES:
1964 zones_manager();
1965 break;
1966
1967 case ACTION_LOOT:
1968 loot();
1969 break;
1970
1971 case ACTION_INVENTORY:
1973 break;
1974
1975 case ACTION_COMPARE:
1977 break;
1978
1979 case ACTION_ORGANIZE:
1981 break;
1982
1983 case ACTION_USE:
1984 // Shell-users are presumed to be able to mess with their inventories, etc
1985 // while in the shell. Eating, gear-changing, and item use are OK.
1987 break;
1988
1989 case ACTION_USE_WIELDED:
1990 u.use_wielded();
1991 break;
1992
1993 case ACTION_WEAR:
1994 wear();
1995 break;
1996
1997 case ACTION_TAKE_OFF:
1998 takeoff();
1999 break;
2000
2001 case ACTION_EAT:
2002 if( !avatar_action::eat_here( u ) ) {
2004 }
2005 break;
2006
2008 if( !avatar_action::eat_here( u ) ) {
2010 }
2011 break;
2012
2013 case ACTION_READ:
2014 // Shell-users are presumed to have the book just at an opening and read it that way
2015 read();
2016 break;
2017
2018 case ACTION_WIELD:
2019 wield();
2020 break;
2021
2022 case ACTION_PICK_STYLE:
2023 u.martial_arts_data->pick_style( u );
2024 break;
2025
2026 case ACTION_RELOAD_ITEM:
2027 reload_item();
2028 break;
2029
2031 reload_weapon();
2032 break;
2033
2036 break;
2037
2038 case ACTION_UNLOAD:
2040 break;
2041
2042 case ACTION_MEND:
2044 break;
2045
2046 case ACTION_THROW: {
2047 item_location loc;
2048 avatar_action::plthrow( g->u, loc );
2049 break;
2050 }
2051
2052 case ACTION_FIRE:
2053 fire();
2054 break;
2055
2056 case ACTION_CAST_SPELL:
2057 cast_spell();
2058 break;
2059
2060 case ACTION_FIRE_BURST: {
2061 if( u.weapon.gun_set_mode( gun_mode_id( "AUTO" ) ) ) {
2063 }
2064 break;
2065 }
2066
2068 if( u.is_armed() && u.weapon.is_gun() && !u.weapon.is_gunmod() ) {
2069 if( u.weapon.gun_all_modes().size() > 1 ) {
2071 } else {
2072 add_msg( m_info, _( "Your %s has only one firing mode." ), u.weapon.display_name() );
2073 }
2074 }
2075 break;
2076
2078 if( u.is_armed() && u.weapon.is_gun() && !u.weapon.is_gunmod() ) {
2080 }
2081 break;
2082
2083 case ACTION_DROP:
2084 // You CAN drop things to your own tile while in the shell.
2085 drop();
2086 break;
2087
2088 case ACTION_DIR_DROP:
2090 add_msg( m_info, _( "You can't drop things to another tile while you're in your shell." ) );
2091 } else {
2093 }
2094 break;
2095 case ACTION_BIONICS:
2096 u.power_bionics();
2097 break;
2098 case ACTION_MUTATIONS:
2100 break;
2101
2102 case ACTION_SORT_ARMOR:
2103 u.sort_armor();
2104 break;
2105
2106 case ACTION_WAIT:
2107 wait();
2108 break;
2109
2110 case ACTION_CRAFT:
2112 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2113 } else if( u.is_mounted() ) {
2114 add_msg( m_info, _( "You can't craft while you're riding." ) );
2115 } else {
2116 u.craft();
2117 }
2118 break;
2119
2120 case ACTION_RECRAFT:
2122 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2123 } else if( u.is_mounted() ) {
2124 add_msg( m_info, _( "You can't craft while you're riding." ) );
2125 } else {
2126 u.recraft();
2127 }
2128 break;
2129
2130 case ACTION_LONGCRAFT:
2132 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2133 } else if( u.is_mounted() ) {
2134 add_msg( m_info, _( "You can't craft while you're riding." ) );
2135 } else {
2136 u.long_craft();
2137 }
2138 break;
2139
2140 case ACTION_DISASSEMBLE:
2141 if( u.controlling_vehicle ) {
2142 add_msg( m_info, _( "You can't disassemble items while driving." ) );
2143 } else if( u.is_mounted() ) {
2144 add_msg( m_info, _( "You can't disassemble items while you're riding." ) );
2145 } else {
2146 u.disassemble();
2147 }
2148 break;
2149
2150 case ACTION_CONSTRUCT:
2151 if( u.in_vehicle ) {
2152 add_msg( m_info, _( "You can't construct while in a vehicle." ) );
2153 } else if( u.has_active_mutation( trait_SHELL2 ) ) {
2154 add_msg( m_info, _( "You can't construct while you're in your shell." ) );
2155 } else if( u.is_mounted() ) {
2156 add_msg( m_info, _( "You can't construct while you're riding." ) );
2157 } else {
2158 construction_menu( false );
2159 }
2160 break;
2161
2162 case ACTION_SLEEP:
2163 if( veh_ctrl ) {
2164 add_msg( m_info, _( "Vehicle control has moved, %s" ),
2165 press_x( ACTION_CONTROL_VEHICLE, _( "new binding is " ),
2166 _( "new default binding is '^'." ) ) );
2167 } else {
2168 sleep();
2169 }
2170 break;
2171
2174 add_msg( m_info, _( "You can't operate a vehicle while you're in your shell." ) );
2175 } else if( u.is_mounted() ) {
2176 u.dismount();
2177 } else {
2179 }
2180 break;
2181
2184 add_msg( m_info, auto_travel_mode ? _( "Auto travel mode ON!" ) : _( "Auto travel mode OFF!" ) );
2185 break;
2186
2188 if( safe_mode == SAFE_MODE_OFF ) {
2190 mostseen = 0;
2191 add_msg( m_info, _( "Safe mode ON!" ) );
2192 } else {
2195 add_msg( m_info, get_option<bool>( "AUTOSAFEMODE" )
2196 ? _( "Safe mode OFF! (Auto safe mode still enabled!)" ) : _( "Safe mode OFF!" ) );
2197 }
2201 }
2202 break;
2203
2205 auto &autosafemode_option = get_options().get_option( "AUTOSAFEMODE" );
2206 add_msg( m_info, autosafemode_option.value_as<bool>()
2207 ? _( "Auto safe mode OFF!" ) : _( "Auto safe mode ON!" ) );
2208 autosafemode_option.setNext();
2209 break;
2210 }
2211
2213 if( safe_mode == SAFE_MODE_STOP ) {
2214 add_msg( m_info, _( "Ignoring enemy!" ) );
2215 for( auto &elem : u.get_mon_visible().new_seen_mon ) {
2216 monster &critter = *elem;
2217 critter.ignoring = rl_dist( u.pos(), critter.pos() );
2218 }
2220 } else if( u.has_effect( effect_laserlocked ) ) {
2221 if( u.has_trait( trait_PROF_CHURL ) ) {
2222 add_msg( m_warning, _( "You make the sign of the cross." ) );
2223 } else {
2224 add_msg( m_info, _( "Ignoring laser targeting!" ) );
2225 }
2228 }
2229 break;
2230
2232 if( safe_mode == SAFE_MODE_STOP && !get_safemode().empty() ) {
2234 add_msg( m_info, _( "Creature whitelisted: %s" ), get_safemode().lastmon_whitelist );
2236 mostseen = 0;
2237 } else {
2238 get_safemode().show();
2239 }
2240 break;
2241
2242 case ACTION_SUICIDE:
2243 if( query_yn( _( "Commit suicide?" ) ) ) {
2244 if( query_yn( _( "REALLY commit suicide?" ) ) ) {
2245 u.moves = 0;
2246 u.place_corpse();
2248 }
2249 }
2250 break;
2251
2252 case ACTION_SAVE:
2253 if( query_yn( _( "Save and quit?" ) ) ) {
2254 if( save() ) {
2255 u.moves = 0;
2256 uquit = QUIT_SAVED;
2257 }
2258 }
2259 break;
2260
2261 case ACTION_QUICKSAVE:
2262 quicksave();
2263 return false;
2264
2265 case ACTION_QUICKLOAD:
2266 quickload();
2267 return false;
2268
2269 case ACTION_PL_INFO:
2270 u.disp_info();
2271 break;
2272
2273 case ACTION_MAP:
2275 break;
2276
2277 case ACTION_SKY:
2278 if( m.is_outside( u.pos() ) ) {
2280 } else {
2281 add_msg( m_info, _( "You can't see the sky from here." ) );
2282 }
2283 break;
2284
2285 case ACTION_MISSIONS:
2286 list_missions();
2287 break;
2288
2289 case ACTION_SCORES:
2291 break;
2292
2293 case ACTION_FACTIONS:
2294 faction_manager_ptr->display();
2295 break;
2296
2297 case ACTION_MORALE:
2298 u.disp_morale();
2299 break;
2300
2301 case ACTION_MESSAGES:
2303 break;
2304
2305 case ACTION_HELP:
2307 break;
2308
2309 case ACTION_OPTIONS:
2310 get_options().show( true );
2311 break;
2312
2313 case ACTION_AUTOPICKUP:
2315 break;
2316
2317 case ACTION_AUTONOTES:
2319 break;
2320
2321 case ACTION_SAFEMODE:
2322 get_safemode().show();
2323 break;
2324
2325 case ACTION_COLOR:
2326 all_colors.show_gui();
2327 break;
2328
2329 case ACTION_WORLD_MODS:
2330 world_generator->show_active_world_mods( world_generator->active_world->active_mod_order );
2331 break;
2332
2333 case ACTION_DEBUG:
2335 break; //don't do anything when sharing and not debugger
2336 }
2338 break;
2339
2342 break;
2343
2346 break;
2347
2350 break;
2351
2354 break;
2355
2357 get_options().get_option( "AUTO_FEATURES" ).setNext();
2358 get_options().save();
2359 //~ Auto Features are now ON/OFF
2360 add_msg( _( "%s are now %s." ),
2361 get_options().get_option( "AUTO_FEATURES" ).getMenuText(),
2362 get_option<bool>( "AUTO_FEATURES" ) ? _( "ON" ) : _( "OFF" ) );
2363 break;
2364
2366 get_options().get_option( "AUTO_PULP_BUTCHER" ).setNext();
2367 get_options().save();
2368 //~ Auto Pulp/Pulp Adjacent/Butcher is now set to x
2369 add_msg( _( "%s is now set to %s." ),
2370 get_options().get_option( "AUTO_PULP_BUTCHER" ).getMenuText(),
2371 get_options().get_option( "AUTO_PULP_BUTCHER" ).getValueName() );
2372 break;
2373
2375 get_options().get_option( "AUTO_MINING" ).setNext();
2376 get_options().save();
2377 //~ Auto Mining is now ON/OFF
2378 add_msg( _( "%s is now %s." ),
2379 get_options().get_option( "AUTO_MINING" ).getMenuText(),
2380 get_option<bool>( "AUTO_MINING" ) ? _( "ON" ) : _( "OFF" ) );
2381 break;
2382
2384 if( g->u.get_value( "THIEF_MODE" ) == "THIEF_ASK" ) {
2385 u.set_value( "THIEF_MODE", "THIEF_HONEST" );
2386 u.set_value( "THIEF_MODE_KEEP", "YES" );
2387 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2388 add_msg( _( "You will not pick up other peoples belongings." ) );
2389 } else if( g->u.get_value( "THIEF_MODE" ) == "THIEF_HONEST" ) {
2390 u.set_value( "THIEF_MODE", "THIEF_STEAL" );
2391 u.set_value( "THIEF_MODE_KEEP", "YES" );
2392 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2393 add_msg( _( "You will pick up also those things that belong to others!" ) );
2394 } else if( g->u.get_value( "THIEF_MODE" ) == "THIEF_STEAL" ) {
2395 u.set_value( "THIEF_MODE", "THIEF_ASK" );
2396 u.set_value( "THIEF_MODE_KEEP", "NO" );
2397 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2398 add_msg( _( "You will be reminded not to steal." ) );
2399 } else {
2400 // ERROR
2401 add_msg( _( "THIEF_MODE CONTAINED BAD VALUE [ %s ]!" ), g->u.get_value( "THIEF_MODE" ) );
2402 }
2403 break;
2404
2406 get_options().get_option( "AUTO_FORAGING" ).setNext();
2407 get_options().save();
2408 //~ Auto Foraging is now set to x
2409 add_msg( _( "%s is now set to %s." ),
2410 get_options().get_option( "AUTO_FORAGING" ).getMenuText(),
2411 get_options().get_option( "AUTO_FORAGING" ).getValueName() );
2412 break;
2413
2415 get_options().get_option( "AUTO_PICKUP" ).setNext();
2416 get_options().save();
2417 //~ Auto pickup is now set to x
2418 add_msg( _( "%s is now set to %s." ),
2419 get_options().get_option( "AUTO_PICKUP" ).getMenuText(),
2420 get_options().get_option( "AUTO_PICKUP" ).getValueName() );
2421 break;
2422
2425 break; //don't do anything when sharing and not debugger
2426 }
2427 display_scent();
2428 break;
2429
2432 break; //don't do anything when sharing and not debugger
2433 }
2434 display_scent();
2435 break;
2436
2439 break; //don't do anything when sharing and not debugger
2440 }
2442 break;
2445 break; //don't do anything when sharing and not debugger
2446 }
2448 break;
2451 break; //don't do anything when sharing and not debugger
2452 }
2454 break;
2455
2458 break; //don't do anything when sharing and not debugger
2459 }
2461 break;
2462
2465 break; //don't do anything when sharing and not debugger
2466 }
2468 break;
2469
2472 break; //don't do anything when sharing and not debugger
2473 }
2475 break;
2476
2478 g->debug_submap_grid_overlay = !g->debug_submap_grid_overlay;
2479 break;
2480
2483 break;
2484
2487 break; //don't do anything when sharing and not debugger
2488 }
2490 if( debug_mode ) {
2491 add_msg( m_info, _( "Debug mode ON!" ) );
2492 } else {
2493 add_msg( m_info, _( "Debug mode OFF!" ) );
2494 }
2495 break;
2496
2497 case ACTION_ZOOM_IN:
2498 zoom_in();
2500 break;
2501
2502 case ACTION_ZOOM_OUT:
2503 zoom_out();
2505 break;
2506
2507 case ACTION_ITEMACTION:
2509 break;
2510
2511 case ACTION_AUTOATTACK:
2513 break;
2514
2515 default:
2516 break;
2517 }
2518 }
2519 if( act != ACTION_TIMEOUT ) {
2520 u.mod_moves( -current_turn.moves_elapsed() );
2521 }
2522 gamemode->post_action( act );
2523
2524 u.movecounter = ( !u.is_dead_state() ? ( before_action_moves - u.moves ) : 0 );
2525 dbg( DL::Info ) << string_format( "%s: [%d] %d - %d = %d", action_ident( act ),
2526 to_turn<int>( calendar::turn ), before_action_moves, u.movecounter, u.moves );
2527 return ( !u.is_dead_state() );
2528}
cata::optional< std::string > press_x_if_bound(action_id act)
Definition: action.cpp:468
bool can_action_change_worldstate(const action_id act)
Lookup whether an action can affect the state of the game world.
Definition: action.cpp:347
action_id look_up_action(const std::string &ident)
Lookup an action ID by its unique string identifier.
Definition: action.cpp:417
action_id handle_main_menu()
Show in-game main menu.
Definition: action.cpp:935
point get_delta_from_movement_action(const action_id act, const iso_rotate rot)
Definition: action.cpp:506
action_id handle_action_menu()
Show the action menu.
Definition: action.cpp:653
@ ACTION_SAFEMODE
Open safemode manager.
Definition: action.h:265
@ ACTION_PEEK
Peek through something (e.g.
Definition: action.h:121
@ ACTION_OPEN
Open an item (e.g.
Definition: action.h:99
@ ACTION_CRAFT
Open crafting menu.
Definition: action.h:199
@ ACTION_DROP
Open the drop-item menu.
Definition: action.h:181
@ ACTION_READ
Open the read menu.
Definition: action.h:153
@ ACTION_TOGGLE_AUTO_PICKUP
Turn auto pickup on/off.
Definition: action.h:309
@ ACTION_MOVE_BACK_LEFT
Move towards bottom-left of screen / decelerate and steer left.
Definition: action.h:51
@ ACTION_ZOOM_IN
Zoom view out.
Definition: action.h:287
@ ACTION_EAT
Open the default consume item menu.
Definition: action.h:149
@ ACTION_SMASH
Smash something.
Definition: action.h:103
@ ACTION_ADVANCEDINV
Open the advanced inventory screen.
Definition: action.h:135
@ ACTION_QUICKSAVE
Quicksave the game.
Definition: action.h:227
@ ACTION_HELP
Display help screen.
Definition: action.h:253
@ ACTION_MESSAGES
Display messages screen.
Definition: action.h:251
@ ACTION_ZONES
Open the zone manager.
Definition: action.h:125
@ ACTION_TOGGLE_PIXEL_MINIMAP
Turn pixel minimap on/off.
Definition: action.h:293
@ ACTION_USE
Open the use menu.
Definition: action.h:141
@ ACTION_QUICKLOAD
Quickload the game.
Definition: action.h:229
@ ACTION_LIST_ITEMS
List items and monsters in a given square.
Definition: action.h:123
@ ACTION_DEBUG
Open debug menu.
Definition: action.h:277
@ ACTION_OPTIONS
Display options window.
Definition: action.h:259
@ ACTION_MOVE_FORTH
Move towards top of screen / accelerate.
Definition: action.h:41
@ ACTION_PICK_STYLE
Open the martial-arts style menu.
Definition: action.h:157
@ ACTION_CONSTRUCT
Open construct menu.
Definition: action.h:205
@ ACTION_MOVE_FORTH_RIGHT
Move towards top-right of screen / accelerate and steer right.
Definition: action.h:43
@ ACTION_SORT_ARMOR
Open the armor sorting menu.
Definition: action.h:189
@ ACTION_OPEN_CONSUME
Open the custom consume item menu.
Definition: action.h:151
@ ACTION_MORALE
Display morale effects screen.
Definition: action.h:249
@ ACTION_NULL
Invalid action used for various lookup errors.
Definition: action.h:24
@ ACTION_RESET_MOVE
Reset movement mode to walk
Definition: action.h:63
@ ACTION_CHAT
Chat with something.
Definition: action.h:117
@ ACTION_RELOAD_WIELDED
Attempt to reload wielded object.
Definition: action.h:163
@ ACTION_MOVE_DOWN
Descend a staircase.
Definition: action.h:57
@ ACTION_MISSIONS
Display missions screen.
Definition: action.h:243
@ ACTION_AUTONOTES
Open autonotes manager.
Definition: action.h:263
@ ACTION_WIELD
Open the wield menu.
Definition: action.h:155
@ ACTION_THROW
Open the throw menu.
Definition: action.h:169
@ ACTION_TOGGLE_AUTO_MINING
Turn auto mining on/off.
Definition: action.h:305
@ ACTION_INVENTORY
Open the primary inventory screen.
Definition: action.h:133
@ ACTION_TOGGLE_AUTOSAFE
Turn automatic triggering of safemode on/off.
Definition: action.h:217
@ ACTION_OPEN_MOVEMENT
Open movement mode menu.
Definition: action.h:69
@ ACTION_COMPARE
Open the item compare screen.
Definition: action.h:137
@ ACTION_SCORES
Display scores screen.
Definition: action.h:245
@ ACTION_BUTCHER
Butcher or disassemble objects in current square.
Definition: action.h:115
@ ACTION_SEC_SELECT
Click on a point with secondary mouse button (usually right button)
Definition: action.h:31
@ ACTION_TOGGLE_CROUCH
Toggle crouch on/off.
Definition: action.h:67
@ ACTION_TOGGLE_HOUR_TIMER
Toggle timing of the game hours.
Definition: action.h:325
@ ACTION_SELECT
Click on a point with primary mouse button (usually left button)
Definition: action.h:29
@ ACTION_MAIN_MENU
Display main menu.
Definition: action.h:255
@ ACTION_DISPLAY_SUBMAP_GRID
Toggle submap grid overlay.
Definition: action.h:323
@ ACTION_WAIT
Open wait menu.
Definition: action.h:197
@ ACTION_ACTIONMENU
Open the action menu.
Definition: action.h:289
@ ACTION_DISASSEMBLE
Open disassemble menu.
Definition: action.h:207
@ ACTION_LOOT
Sort out the loot.
Definition: action.h:127
@ ACTION_TOGGLE_FULLSCREEN
Toggle full-screen mode.
Definition: action.h:275
@ ACTION_MAP
Display over-map.
Definition: action.h:239
@ ACTION_MEND
Open the mending menu (e.g.
Definition: action.h:167
@ ACTION_TOGGLE_THIEF_MODE
Toggle permanent attitude to stealing.
Definition: action.h:219
@ ACTION_USE_WIELDED
Use currently wielded item.
Definition: action.h:143
@ ACTION_PL_INFO
Display player status screen.
Definition: action.h:237
@ ACTION_DISPLAY_SCENT_TYPE
Toggle scent type map.
Definition: action.h:281
@ ACTION_TOGGLE_AUTO_FORAGING
Turn auto foraging on/off.
Definition: action.h:307
@ ACTION_FIRE_BURST
Burst-fire the current weapon.
Definition: action.h:173
@ ACTION_BIONICS
Open the bionics menu.
Definition: action.h:185
@ ACTION_CONTROL_VEHICLE
Open vehicle control menu.
Definition: action.h:211
@ ACTION_SAVE
Save the game and quit.
Definition: action.h:225
@ ACTION_MOVE_UP
Ascend a staircase.
Definition: action.h:59
@ ACTION_TOGGLE_PANEL_ADM
Turn admin panel on/off.
Definition: action.h:295
@ ACTION_TOGGLE_AUTO_PULP_BUTCHER
Change auto pulp/butcher mode.
Definition: action.h:303
@ ACTION_TOGGLE_AUTO_TRAVEL_MODE
Turn auto travel mode on/off.
Definition: action.h:213
@ ACTION_COLOR
Open color manager.
Definition: action.h:267
@ ACTION_TIMEOUT
Input timeout.
Definition: action.h:39
@ ACTION_TOGGLE_RUN
Toggle run on/off.
Definition: action.h:65
@ ACTION_FACTIONS
Display factions screen.
Definition: action.h:247
@ ACTION_GRAB
Grab or let go of an object.
Definition: action.h:111
@ ACTION_MOVE_BACK
Move towards bottom of screen / decelerate.
Definition: action.h:49
@ ACTION_CAST_SPELL
Cast a spell (only if any spells are known)
Definition: action.h:179
@ ACTION_DIR_DROP
Drop items in a given direction.
Definition: action.h:183
@ ACTION_AUTOATTACK
Auto select and attack hostile creature within range.
Definition: action.h:191
@ ACTION_CYCLE_MOVE
Cycle run/walk/crouch mode.
Definition: action.h:61
@ ACTION_SKY
Show sky state for trying to predict weather.
Definition: action.h:241
@ ACTION_FIRE
Fire the wielded weapon, or open fire menu if none.
Definition: action.h:171
@ ACTION_PAUSE
Pause an on-going activity.
Definition: action.h:37
@ ACTION_MOVE_BACK_RIGHT
Move towards bottom-right of screen / decelerate and steer right.
Definition: action.h:47
@ ACTION_MUTATIONS
Open the mutations menu.
Definition: action.h:187
@ ACTION_HAUL
Haul pile of items, or let go of them.
Definition: action.h:113
@ ACTION_MOVE_RIGHT
Move / steer right.
Definition: action.h:45
@ ACTION_SLEEP
Open sleep menu.
Definition: action.h:209
@ ACTION_ITEMACTION
Open the item uses menu.
Definition: action.h:291
@ ACTION_MOVE_LEFT
Move / steer left.
Definition: action.h:53
@ ACTION_SELECT_DEFAULT_AMMO
Change default ammo for current weapon.
Definition: action.h:177
@ ACTION_AUTOPICKUP
Open autopickup manager.
Definition: action.h:261
@ ACTION_SUICIDE
Commit suicide.
Definition: action.h:231
@ NUM_ACTIONS
Not an action, serves as count of enumerated actions.
Definition: action.h:327
@ ACTION_ZOOM_OUT
Zoom view in.
Definition: action.h:285
@ ACTION_SELECT_FIRE_MODE
Change fire mode of the current weapon.
Definition: action.h:175
@ ACTION_UNLOAD
Open the unload item (e.g.
Definition: action.h:165
@ ACTION_RECRAFT
Repeat last craft command.
Definition: action.h:201
@ ACTION_TAKE_OFF
Open the take-off clothing selection menu.
Definition: action.h:147
@ ACTION_PICKUP_FEET
Pick up items from current square.
Definition: action.h:109
@ ACTION_TOGGLE_AUTO_FEATURES
Turn auto features on/off.
Definition: action.h:301
@ ACTION_WORLD_MODS
Open active world mods.
Definition: action.h:269
@ ACTION_TOGGLE_DEBUG_MODE
Toggle debug mode.
Definition: action.h:283
@ ACTION_ORGANIZE
Swap inventory letters.
Definition: action.h:139
@ ACTION_MOVE_FORTH_LEFT
Move towards top-left of screen / accelerate and steer left.
Definition: action.h:55
@ ACTION_RELOAD_TILESET
Reload current tileset.
Definition: action.h:299
@ ACTION_CLOSE
Close an item (e.g.
Definition: action.h:101
@ ACTION_RELOAD_WEAPON
Attempt to reload wielded weapon, then fall back to the load item select menu.
Definition: action.h:161
@ ACTION_RELOAD_ITEM
Open the load item (e.g.
Definition: action.h:159
@ ACTION_PICKUP
Pick up items from current/adjacent squares.
Definition: action.h:107
@ ACTION_LONGCRAFT
Open batch crafting menu.
Definition: action.h:203
@ ACTION_WEAR
Open the wear clothing selection menu.
Definition: action.h:145
void create_advanced_inv()
auto_notes::auto_note_settings & get_auto_notes_settings()
Definition: auto_note.cpp:386
auto_pickup::player_settings & get_auto_pickup()
Definition: auto_pickup.cpp:38
bool tile_iso
Using isometric tileset.
bool debug_mode
Extended debugging mode, can be toggled during game.
bool has_active_mutation(const trait_id &b) const
Definition: mutation.cpp:367
pimpl< character_martial_arts > martial_arts_data
Definition: character.h:1589
bool has_active_item(const itype_id &id) const
Whether the player carries an active item of the given item type.
Definition: character.cpp:2550
void place_corpse()
std::set< tripoint > get_path_avoid() const override
Returns a set of points we do not want to path through.
Definition: character.cpp:9937
bool has_destination_activity() const
bool is_auto_moving() const
void start_destination_activity()
action_id get_next_auto_move_direction()
const pathfinding_settings & get_pathfinding_settings() const override
Returns settings for pathfinding.
Definition: character.cpp:9951
bool is_armed() const
Returns true if the character is wielding something.
Definition: melee.cpp:145
void dismount()
Definition: character.cpp:1240
item weapon
Definition: character.h:1585
void set_value(const std::string &key, const std::string &value)
Definition: creature.cpp:1328
std::string get_value(const std::string &key) const
Definition: creature.cpp:1338
void mod_moves(int nmoves)
Definition: creature.cpp:1405
void cycle_move_mode()
Definition: avatar.cpp:1198
void toggle_map_memory()
Definition: avatar.cpp:117
void toggle_crouch_mode()
Definition: avatar.cpp:1182
void toggle_run_mode()
Definition: avatar.cpp:1173
void disp_morale()
Provides the window and detailed morale data.
Definition: avatar.cpp:985
void reset_move_mode()
Definition: avatar.cpp:1191
void item_action_menu()
void display_radiation()
Definition: game.cpp:11769
void list_missions()
Definition: mission_ui.cpp:22
input_context get_player_input(std::string &action)
bool try_get_left_click_action(action_id &act, const tripoint &mouse_target)
Definition: game.cpp:2605
void wield()
Definition: game.cpp:9098
void set_safe_mode(safe_mode_type mode)
Definition: game.cpp:9171
void reload_wielded(bool prompt=false)
Definition: game.cpp:8931
cata::optional< tripoint > look_around()
Definition: game.cpp:6839
void pickup_feet()
Definition: game.cpp:5896
void zones_manager()
Definition: game.cpp:6364
int turnssincelastmon
Definition: game.h:1069
void display_visibility()
Definition: game.cpp:11683
void display_scent()
Definition: game.cpp:11648
bool save()
Returns false if saving failed.
Definition: game.cpp:3098
void butcher()
Definition: game.cpp:8558
void display_temperature()
Definition: game.cpp:11669
bool auto_travel_mode
Definition: game.h:1066
void zoom_out()
Definition: game.cpp:7306
void toggle_pixel_minimap()
Definition: game.cpp:508
void toggle_debug_hour_timer()
Definition: game.cpp:11715
void display_transparency()
Definition: game.cpp:11776
void list_items_monsters()
Definition: game.cpp:7483
void chat()
Definition: npctalk.cpp:393
void quickload()
Definition: game.cpp:11811
void pickup()
Definition: game.cpp:5874
void vertical_move(int z, bool force, bool peeking=false)
Moves the player vertically.
Definition: game.cpp:10496
void open_consume_item_menu()
void display_lighting()
Definition: game.cpp:11743
void control_vehicle()
Definition: game.cpp:5444
void peek()
Definition: game.cpp:5903
void drop()
Definition: game.cpp:8297
bool try_get_right_click_action(action_id &act, const tripoint &mouse_target)
Definition: game.cpp:2633
void reload_weapon(bool try_everything=true)
Definition: game.cpp:8941
bool check_safe_mode_allowed(bool repeat_safe_mode_warnings=true)
Check whether movement is allowed according to safe mode settings.
Definition: game.cpp:9109
void zoom_in()
Definition: game.cpp:7318
void toggle_fullscreen()
Definition: game.cpp:498
void display_vehicle_ai()
Definition: game.cpp:11676
void reload_item()
Definition: game.cpp:8917
void reload_tileset()
Definition: game.cpp:519
void mark_main_ui_adaptor_resize() const
Definition: game.cpp:3346
void drop_in_direction()
Definition: game.cpp:8302
void display_help()
Definition: help.cpp:140
cata::optional< tripoint > get_coordinates(const catacurses::window &capture_win_)
Get the coordinates associated with the last mouse click (if any).
Definition: input.cpp:1338
input_event get_raw_input()
Temporary method to retrieve the raw input received, so that input_contexts can be used in screens wh...
Definition: input.cpp:1299
action_id display_menu(bool permit_execute_action=false)
Displays the possible actions in the current context and their keybindings.
Definition: input.cpp:999
std::string get_keyname(int ch, input_event_t inp_type, bool portable=false) const
Get the key name associated with the given keyboard keycode.
Definition: input.cpp:415
bool is_gun() const
Can this item be used to perform a ranged attack?
Definition: item.cpp:6367
void gun_cycle_mode()
Switch to the next available firing mode.
Definition: item.cpp:7758
std::string display_name(unsigned int quantity=1) const
Returns the item name and the charges or contained charges (if the item can have charges at all).
Definition: item.cpp:4706
bool is_gunmod() const
Definition: item.cpp:6397
std::map< gun_mode_id, gun_mode > gun_all_modes() const
Get all possible modes for this gun inclusive of any attached gunmods.
Definition: item.cpp:7677
bool gun_set_mode(const gun_mode_id &mode)
Try to set the mode for a gun, returning false if no such mode is possible.
Definition: item.cpp:7749
bool is_outside(const tripoint &p) const
Definition: map.cpp:2557
std::vector< tripoint > route(const tripoint &f, const tripoint &t, const pathfinding_settings &settings, const std::set< tripoint > &pre_closed={{ }}) const
Calculate the best path using A*.
const tripoint & pos() const override
Definition: monster.cpp:255
short ignoring
Definition: monster.h:505
cOpt & get_option(const std::string &name)
Definition: options.cpp:3334
std::string show(bool ingame=false, bool world_options_only=false, const std::function< bool()> &on_quit=nullptr)
Definition: options.cpp:2722
void show_adm()
Definition: panels.cpp:2405
void pause()
Definition: player.cpp:756
void craft(const tripoint &loc=tripoint_zero)
Start various types of crafts.
Definition: crafting.cpp:335
void disp_info()
Handles and displays detailed character info for the '@' screen.
void sort_armor()
Draws the UI and handles player input for the armor re-ordering window.
void power_mutations()
Definition: mutation_ui.cpp:89
void use_wielded()
Uses the current wielded weapon.
Definition: player.cpp:3229
int movecounter
Definition: player.h:696
void power_bionics()
Generates and handles the UI for player interaction with installed bionics.
Definition: bionics_ui.cpp:528
void recraft(const tripoint &loc=tripoint_zero)
Definition: crafting.cpp:346
void long_craft(const tripoint &loc=tripoint_zero)
Definition: crafting.cpp:355
void add_rule(const std::string &rule_in, Creature::Attitude attitude_in, int proximity_in, rule_state state_in)
void show()
Definition: safemode_ui.cpp:39
int moves_elapsed()
#define all_colors
Definition: color.h:15
construction_id construction_menu(const bool blueprint)
@ Info
Information (default: enabled).
@ RULE_WHITELISTED
Definition: enums.h:53
@ SAFE_MODE_OFF
Definition: game.h:77
@ QUIT_SAVED
Definition: game.h:70
static void open_movement_mode_menu()
static void smash()
static void open()
#define dbg(x)
static void takeoff()
static void read()
static void wait()
static const efftype_id effect_laserlocked("laserlocked")
static void rcdrive(const point &d)
static void wear()
static void close()
static const bionic_id bio_remote("bio_remote")
static void pldrive(const tripoint &p)
static void haul()
static const trait_id trait_SHELL2("SHELL2")
static const trait_id trait_PROF_CHURL("PROF_CHURL")
static void cast_spell()
static void loot()
static void fire()
static void grab()
static void sleep()
static const itype_id itype_radiocontrol("radiocontrol")
help & get_help()
Definition: help.cpp:30
bool isDebugger()
Definition: mapsharing.cpp:65
bool isCompetitive()
Definition: mapsharing.cpp:35
void use_item(avatar &you, item_location &loc)
bool eat_here(avatar &you)
void autoattack(avatar &you, map &m)
void eat(avatar &you)
Eat food or fuel 'E' (or 'a')
void fire_wielded_weapon(avatar &you)
Checks if the wielded weapon is a gun and can be fired then starts interactive aiming.
void plthrow(avatar &you, item_location loc, const cata::optional< tripoint > &blind_throw_from_pos=cata::nullopt)
void mend(avatar &you, item_location loc)
void unload(avatar &you)
void debug()
void close_door(map &m, Character &who, const tripoint &closep)
Handles deducting moves, printing messages (only non-NPCs cause messages), actually closing it,...
Definition: gates.cpp:256
void compare(player &p, const cata::optional< tripoint > &offset)
void common(avatar &you)
void swap_letters(player &p)
void prompt_select_default_ammo_for(avatar &u, const item &w)
Prompts to select default ammo compatible with provided gun.
Definition: ranged.cpp:3742
void display_visible_weather()
Display overmap like with display() and display the weather that is within line of sight.
void display()
Display overmap centered at the player's position.
options_manager & get_options()
Definition: options.cpp:142
T get_option(const std::string &name)
Definition: options.h:368
static constexpr point point_south_west
Definition: point.h:281
static constexpr point point_north_east
Definition: point.h:277
static constexpr point point_north_west
Definition: point.h:283
An instance of an input, like a keypress etc.
Definition: input.h:95
std::vector< int > sequence
Definition: input.h:101
int get_first_input() const
Definition: input.cpp:100
input_event_t type
Definition: input.h:96
void handbrake()

References _, Creature::A_ANY, achievements_tracker_ptr, act, action, ACTION_ACTIONMENU, ACTION_ADVANCEDINV, ACTION_AUTOATTACK, ACTION_AUTONOTES, ACTION_AUTOPICKUP, ACTION_BIONICS, ACTION_BUTCHER, ACTION_CAST_SPELL, ACTION_CENTER, ACTION_CHAT, ACTION_CLOSE, ACTION_COLOR, ACTION_COMPARE, ACTION_CONSTRUCT, ACTION_CONTROL_VEHICLE, ACTION_CRAFT, ACTION_CYCLE_MOVE, ACTION_DEBUG, ACTION_DIR_DROP, ACTION_DISASSEMBLE, ACTION_DISPLAY_LIGHTING, ACTION_DISPLAY_RADIATION, ACTION_DISPLAY_SCENT, ACTION_DISPLAY_SCENT_TYPE, ACTION_DISPLAY_SUBMAP_GRID, ACTION_DISPLAY_TEMPERATURE, ACTION_DISPLAY_TRANSPARENCY, ACTION_DISPLAY_VEHICLE_AI, ACTION_DISPLAY_VISIBILITY, ACTION_DROP, ACTION_EAT, ACTION_EXAMINE, ACTION_FACTIONS, ACTION_FIRE, ACTION_FIRE_BURST, ACTION_GRAB, ACTION_HAUL, ACTION_HELP, action_ident(), ACTION_IGNORE_ENEMY, ACTION_INVENTORY, ACTION_ITEMACTION, ACTION_KEYBINDINGS, ACTION_LIST_ITEMS, ACTION_LONGCRAFT, ACTION_LOOK, ACTION_LOOT, ACTION_MAIN_MENU, ACTION_MAP, ACTION_MEND, ACTION_MESSAGES, ACTION_MISSIONS, ACTION_MORALE, ACTION_MOVE_BACK, ACTION_MOVE_BACK_LEFT, ACTION_MOVE_BACK_RIGHT, ACTION_MOVE_DOWN, ACTION_MOVE_FORTH, ACTION_MOVE_FORTH_LEFT, ACTION_MOVE_FORTH_RIGHT, ACTION_MOVE_LEFT, ACTION_MOVE_RIGHT, ACTION_MOVE_UP, ACTION_MUTATIONS, ACTION_NULL, ACTION_OPEN, ACTION_OPEN_CONSUME, ACTION_OPEN_MOVEMENT, ACTION_OPTIONS, ACTION_ORGANIZE, ACTION_PAUSE, ACTION_PEEK, ACTION_PICK_STYLE, ACTION_PICKUP, ACTION_PICKUP_FEET, ACTION_PL_INFO, ACTION_QUICKLOAD, ACTION_QUICKSAVE, ACTION_READ, ACTION_RECRAFT, ACTION_RELOAD_ITEM, ACTION_RELOAD_TILESET, ACTION_RELOAD_WEAPON, ACTION_RELOAD_WIELDED, ACTION_RESET_MOVE, ACTION_SAFEMODE, ACTION_SAVE, ACTION_SCORES, ACTION_SEC_SELECT, ACTION_SELECT, ACTION_SELECT_DEFAULT_AMMO, ACTION_SELECT_FIRE_MODE, ACTION_SHIFT_E, ACTION_SHIFT_N, ACTION_SHIFT_NE, ACTION_SHIFT_NW, ACTION_SHIFT_S, ACTION_SHIFT_SE, ACTION_SHIFT_SW, ACTION_SHIFT_W, ACTION_SKY, ACTION_SLEEP, ACTION_SMASH, ACTION_SORT_ARMOR, ACTION_SUICIDE, ACTION_TAKE_OFF, ACTION_THROW, ACTION_TIMEOUT, ACTION_TOGGLE_AUTO_FEATURES, ACTION_TOGGLE_AUTO_FORAGING, ACTION_TOGGLE_AUTO_MINING, ACTION_TOGGLE_AUTO_PICKUP, ACTION_TOGGLE_AUTO_PULP_BUTCHER, ACTION_TOGGLE_AUTO_TRAVEL_MODE, ACTION_TOGGLE_AUTOSAFE, ACTION_TOGGLE_CROUCH, ACTION_TOGGLE_DEBUG_MODE, ACTION_TOGGLE_FULLSCREEN, ACTION_TOGGLE_HOUR_TIMER, ACTION_TOGGLE_MAP_MEMORY, ACTION_TOGGLE_PANEL_ADM, ACTION_TOGGLE_PIXEL_MINIMAP, ACTION_TOGGLE_RUN, ACTION_TOGGLE_SAFEMODE, ACTION_TOGGLE_THIEF_MODE, ACTION_UNLOAD, ACTION_USE, ACTION_USE_WIELDED, ACTION_WAIT, ACTION_WEAR, ACTION_WHITELIST_ENEMY, ACTION_WIELD, ACTION_WORLD_MODS, ACTION_ZONES, ACTION_ZOOM_IN, ACTION_ZOOM_OUT, add_msg(), safemode::add_rule(), all_colors, auto_travel_mode, avatar_action::autoattack(), bio_remote, butcher(), can_action_change_worldstate(), cast_spell(), chat(), check_safe_mode_allowed(), Character::clear_destination(), close(), doors::close_door(), game_menus::inv::common(), game_menus::inv::compare(), construction_menu(), control_vehicle(), Character::controlling_vehicle, player::craft(), create_advanced_inv(), avatar::cycle_move_mode(), dbg, debug_menu::debug(), debug_mode, destination_preview, player::disassemble(), Character::dismount(), player::disp_info(), avatar::disp_morale(), ui::omap::display(), help::display_help(), display_lighting(), input_context::display_menu(), Messages::display_messages(), item::display_name(), display_radiation(), display_scent(), display_temperature(), display_transparency(), display_vehicle_ai(), display_visibility(), ui::omap::display_visible_weather(), driving_view_offset, drop(), drop_in_direction(), avatar_action::eat(), avatar_action::eat_here(), effect_laserlocked, examine(), faction_manager_ptr, fire(), avatar_action::fire_wielded_weapon(), g, gamemode, get_auto_notes_settings(), get_auto_pickup(), input_context::get_coordinates(), get_delta_from_movement_action(), input_event::get_first_input(), get_help(), input_manager::get_keyname(), get_kill_tracker(), panel_manager::get_manager(), avatar::get_mon_visible(), Character::get_next_auto_move_direction(), options_manager::get_option(), get_option(), get_options(), Character::get_path_avoid(), Character::get_pathfinding_settings(), get_player_input(), input_context::get_raw_input(), get_safemode(), Creature::get_value(), grab(), item::gun_all_modes(), item::gun_cycle_mode(), item::gun_set_mode(), handbrake(), handle_action_menu(), handle_main_menu(), Character::has_active_bionic(), Character::has_active_item(), Character::has_active_mutation(), Character::has_destination(), Character::has_destination_activity(), Creature::has_effect(), Character::has_trait(), haul(), monster::ignoring, Character::in_vehicle, Info, inp_mngr, Character::is_armed(), Character::is_auto_moving(), player::is_dead_state(), item::is_gun(), item::is_gunmod(), Character::is_mounted(), map::is_outside(), MAP_SHARING::isCompetitive(), MAP_SHARING::isDebugger(), item_action_menu(), itype_radiocontrol, list_items_monsters(), list_missions(), player::long_craft(), look_around(), look_up_action(), loot(), m, m_bad, m_info, m_warning, mark_main_ui_adaptor_resize(), Character::martial_arts_data, avatar_action::mend(), MF_RIDEABLE_MECH, Creature::mod_moves(), mostseen, Character::mounted_creature, avatar_action::move(), player::movecounter, Creature::moves, user_turn::moves_elapsed(), om_direction::name(), monster_visible_info::new_seen_mon, no, cata::nullopt, NUM_ACTIONS, open(), open_consume_item_menu(), open_movement_mode_menu(), player::pause(), peek(), pickup(), pickup_feet(), Character::place_corpse(), pldrive(), avatar_action::plthrow(), point_east, point_north, point_north_east, point_north_west, point_south, point_south_east, point_south_west, point_west, point_zero, Character::pos(), monster::pos(), Character::posx(), Character::posy(), Character::posz(), player::power_bionics(), player::power_mutations(), press_x(), press_x_if_bound(), ranged::prompt_select_default_ammo_for(), query_yn(), quickload(), quicksave(), QUIT_DIED, QUIT_SAVED, QUIT_SUICIDE, QUIT_WATCH, rcdrive(), read(), player::recraft(), reload_item(), reload_tileset(), reload_weapon(), reload_wielded(), remoteveh(), Creature::remove_effect(), avatar::reset_move_mode(), rl_dist(), map::route(), RULE_WHITELISTED, safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAFE_MODE_STOP, safe_mode_warning_logged, save(), options_manager::save(), Character::sees(), SEEX, input_event::sequence, Character::set_destination(), set_safe_mode(), Creature::set_value(), options_manager::cOpt::setNext(), auto_pickup::player_settings::show(), safemode::show(), options_manager::show(), panel_manager::show_adm(), auto_notes::auto_note_settings::show_gui(), show_scores_ui(), sleep(), smash(), player::sort_armor(), Character::start_destination_activity(), stats(), string_format(), game_menus::inv::swap_letters(), takeoff(), tile_iso, avatar::toggle_crouch_mode(), toggle_debug_hour_timer(), toggle_fullscreen(), avatar::toggle_map_memory(), toggle_pixel_minimap(), avatar::toggle_run_mode(), trait_PROF_CHURL, trait_SHELL2, tripoint_above, tripoint_below, try_get_left_click_action(), try_get_right_click_action(), calendar::turn, turnssincelastmon, input_event::type, u, avatar_action::unload(), uquit, avatar_action::use_item(), use_tiles, player::use_wielded(), user_action_counter, map::veh_at(), vertical_move(), player::view_offset, w_terrain, wait(), Character::weapon, wear(), wield(), world_generator, point::x, tripoint::x, point::y, tripoint::y, yes, zones_manager(), zoom_in(), and zoom_out().

Referenced by do_turn().

◆ handle_key_blocking_activity()

void game::handle_key_blocking_activity ( )
private

Definition at line 2055 of file game.cpp.

2056{
2058 const std::string action = ctxt.handle_input( 0 );
2059 bool refresh = true;
2060 if( action == "pause" ) {
2062 cancel_activity_query( _( "Confirm:" ) );
2063 }
2064 } else if( action == "player_data" ) {
2065 u.disp_info();
2066 } else if( action == "messages" ) {
2068 } else if( action == "help" ) {
2070 } else if( action != "HELP_KEYBINDINGS" ) {
2071 refresh = false;
2072 }
2073 if( refresh ) {
2076 }
2077}
bool cancel_activity_query(const std::string &text)
Asks if the player wants to cancel their activity, and if so cancels it.
Definition: game.cpp:1839
const std::string & handle_input()
Handles input and returns the next action in the queue.
Definition: input.cpp:854
bool interruptable_with_kb
Controls whether this activity can be cancelled with 'pause' action.
void refresh()

References _, action, Character::activity, cancel_activity_query(), player::disp_info(), help::display_help(), Messages::display_messages(), get_default_mode_input_context(), get_help(), input_context::handle_input(), player_activity::interruptable_with_kb, ui_manager::redraw(), catacurses::refresh(), refresh_display(), and u.

Referenced by process_voluntary_act_interrupt().

◆ handle_mouseview()

bool game::handle_mouseview ( input_context ctxt,
std::string &  action 
)
private

Definition at line 2312 of file game.cpp.

2313{
2314 cata::optional<tripoint> liveview_pos;
2315
2316 do {
2317 action = ctxt.handle_input();
2318 if( action == "MOUSE_MOVE" ) {
2319 const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
2320 if( mouse_pos && ( !liveview_pos || *mouse_pos != *liveview_pos ) ) {
2321 liveview_pos = mouse_pos;
2322 liveview.show( *liveview_pos );
2323 } else if( !mouse_pos ) {
2324 liveview_pos.reset();
2325 liveview.hide();
2326 }
2328 }
2329 } while( action == "MOUSE_MOVE" ); // Freeze animation when moving the mouse
2330
2331 if( action != "TIMEOUT" ) {
2332 // Keyboard event, break out of animation loop
2333 liveview.hide();
2334 return false;
2335 }
2336
2337 // Mouse movement or un-handled key
2338 return true;
2339}
void reset() noexcept
Definition: optional.h:155
void hide()
Definition: live_view.cpp:33
void show(const tripoint &p)
Definition: live_view.cpp:38

References action, input_context::get_coordinates(), input_context::handle_input(), live_view::hide(), liveview, ui_manager::redraw(), cata::optional< T >::reset(), live_view::show(), and w_terrain.

Referenced by get_player_input().

◆ has_gametype()

bool game::has_gametype ( ) const

Definition at line 622 of file game.cpp.

623{
624 return gamemode && gamemode->id() != SGAME_NULL;
625}

References gamemode, and SGAME_NULL.

◆ init_autosave()

void game::init_autosave ( )
private

Definition at line 11783 of file game.cpp.

11784{
11786 last_save_timestamp = time( nullptr );
11787}

References last_save_timestamp, and moves_since_last_save.

Referenced by load(), and start_game().

◆ inv_map_splice()

item_location game::inv_map_splice ( item_filter  filter,
const std::string &  title,
int  radius = 0,
const std::string &  none_message = "" 
)

Custom-filtered menu for inventory and nearby items and those that within specified radius.

Definition at line 392 of file game_inventory.cpp.

394{
396 title, radius, none_message );
397}
static item_location_filter convert_filter(const item_filter &filter)
static item_location inv_internal(player &u, const inventory_selector_preset &preset, const std::string &title, int radius, const std::string &none_message, const std::string &hint=std::string())
std::string title(holiday current_holiday)
Definition: path_info.cpp:330

References convert_filter(), inv_internal(), PATH_INFO::title(), and u.

Referenced by reload_item().

◆ invalidate_main_ui_adaptor()

void game::invalidate_main_ui_adaptor ( ) const

◆ inventory_item_menu()

int game::inventory_item_menu ( item_location  locThisItem,
const std::function< int()> &  startx = []() { return 0; },
const std::function< int()> &  width = []() { return 50; },
inventory_item_menu_positon  position = RIGHT_OF_INFO 
)

Definition at line 2087 of file game.cpp.

2091{
2092 int cMenu = static_cast<int>( '+' );
2093
2094 item &oThisItem = *locThisItem;
2095 if( u.has_item( oThisItem ) ) {
2096#if defined(__ANDROID__)
2097 if( get_option<bool>( "ANDROID_INVENTORY_AUTOADD" ) ) {
2098 add_key_to_quick_shortcuts( oThisItem.invlet, "INVENTORY", false );
2099 }
2100#endif
2101
2102 std::vector<iteminfo> vThisItem;
2103 std::vector<iteminfo> vDummy;
2104
2105 const bool bHPR = get_auto_pickup().has_rule( &oThisItem );
2106 const bool cant_unwield_weapon = u.weapon.has_flag( "NO_UNWIELD" );
2107 const bool cant_drop_this = cant_unwield_weapon && u.is_wielding( oThisItem );
2108 const hint_rating rate_wield_item = cant_unwield_weapon ? hint_rating::cant :
2110 const hint_rating rate_drop_item = cant_drop_this ? hint_rating::cant :
2112
2113 uilist action_menu;
2114 action_menu.allow_anykey = true;
2115 const auto addentry = [&]( const char key, const std::string & text, const hint_rating hint ) {
2116 // The char is used as retval from the uilist *and* as hotkey.
2117 action_menu.addentry( key, true, key, text );
2118 auto &entry = action_menu.entries.back();
2119 switch( hint ) {
2120 case hint_rating::cant:
2121 entry.text_color = c_light_gray;
2122 break;
2123 case hint_rating::iffy:
2124 entry.text_color = c_light_red;
2125 break;
2126 case hint_rating::good:
2127 entry.text_color = c_light_green;
2128 break;
2129 }
2130 };
2131 addentry( 'a', pgettext( "action", "activate" ), u.rate_action_use( oThisItem ) );
2132 addentry( 'R', pgettext( "action", "read" ), u.rate_action_read( oThisItem ) );
2133 addentry( 'E', pgettext( "action", "eat" ), u.rate_action_eat( oThisItem ) );
2134 addentry( 'W', pgettext( "action", "wear" ), u.rate_action_wear( oThisItem ) );
2135 addentry( 'w', pgettext( "action", "wield" ), rate_wield_item );
2136 addentry( 't', pgettext( "action", "throw" ), rate_drop_item );
2137 addentry( 'c', pgettext( "action", "change side" ), u.rate_action_change_side( oThisItem ) );
2138 addentry( 'T', pgettext( "action", "take off" ), u.rate_action_takeoff( oThisItem ) );
2139 addentry( 'd', pgettext( "action", "drop" ), rate_drop_item );
2140 addentry( 'U', pgettext( "action", "unload" ), u.rate_action_unload( oThisItem ) );
2141 addentry( 'r', pgettext( "action", "reload" ), u.rate_action_reload( oThisItem ) );
2142 addentry( 'p', pgettext( "action", "part reload" ), u.rate_action_reload( oThisItem ) );
2143 addentry( 'm', pgettext( "action", "mend" ), u.rate_action_mend( oThisItem ) );
2144 addentry( 'D', pgettext( "action", "disassemble" ), u.rate_action_disassemble( oThisItem ) );
2145
2146 if( oThisItem.is_favorite ) {
2147 addentry( 'f', pgettext( "action", "unfavorite" ), hint_rating::good );
2148 } else {
2149 addentry( 'f', pgettext( "action", "favorite" ), hint_rating::good );
2150 }
2151
2152 addentry( '=', pgettext( "action", "reassign" ), hint_rating::good );
2153
2154 if( bHPR ) {
2155 addentry( '-', _( "Autopickup" ), hint_rating::iffy );
2156 } else {
2157 addentry( '+', _( "Autopickup" ), hint_rating::good );
2158 }
2159
2160 int iScrollPos = 0;
2161 oThisItem.info( true, vThisItem );
2162
2163 action_menu.w_y_setup = 0;
2164 action_menu.w_x_setup = [&]( const int popup_width ) -> int {
2165 switch( position )
2166 {
2167 default:
2169 return 0;
2170 case LEFT_OF_INFO:
2171 return iStartX() - popup_width;
2172 case RIGHT_OF_INFO:
2173 return iStartX() + iWidth();
2174 case LEFT_TERMINAL_EDGE:
2175 return TERMX - popup_width;
2176 }
2177 };
2178 // Filtering isn't needed, the number of entries is manageable.
2179 action_menu.filtering = false;
2180 // Default menu border color is different, this matches the border of the item info window.
2181 action_menu.border_color = BORDER_COLOR;
2182
2183 item_info_data data( oThisItem.tname(), oThisItem.type_name(), vThisItem, vDummy, iScrollPos );
2184 data.without_getch = true;
2185
2186 catacurses::window w_info;
2187 int iScrollHeight = 0;
2188
2189 std::unique_ptr<ui_adaptor> ui = std::make_unique<ui_adaptor>();
2190 ui->on_screen_resize( [&]( ui_adaptor & ui ) {
2191 w_info = catacurses::newwin( TERMY, iWidth(), point( iStartX(), 0 ) );
2192 iScrollHeight = TERMY - 2;
2193 ui.position_from_window( w_info );
2194 } );
2195 ui->mark_resize();
2196
2197 ui->on_redraw( [&]( const ui_adaptor & ) {
2198 draw_item_info( w_info, data );
2199 } );
2200
2201 bool exit = false;
2202 do {
2203 const int prev_selected = action_menu.selected;
2204 action_menu.query( false );
2205 if( action_menu.ret >= 0 ) {
2206 cMenu = action_menu.ret; /* Remember: hotkey == retval, see addentry above. */
2207 } else if( action_menu.ret == UILIST_UNBOUND && action_menu.keypress == KEY_RIGHT ) {
2208 // Simulate KEY_RIGHT == '\n' (confirm currently selected entry) for compatibility with old version.
2209 // TODO: ideally this should be done in the uilist, maybe via a callback.
2210 cMenu = action_menu.ret = action_menu.entries[action_menu.selected].retval;
2211 } else if( action_menu.keypress == KEY_PPAGE || action_menu.keypress == KEY_NPAGE ) {
2212 cMenu = action_menu.keypress;
2213 // Prevent the menu from scrolling with this key. TODO: Ideally the menu
2214 // could be instructed to ignore these two keys instead of scrolling.
2215 action_menu.selected = prev_selected;
2216 action_menu.fselected = prev_selected;
2217 action_menu.vshift = 0;
2218 } else {
2219 cMenu = 0;
2220 }
2221
2222 if( action_menu.ret != UILIST_WAIT_INPUT && action_menu.ret != UILIST_UNBOUND ) {
2223 exit = true;
2224 ui = nullptr;
2225 }
2226
2227 switch( cMenu ) {
2228 case 'a':
2229 avatar_action::use_item( u, locThisItem );
2230 break;
2231 case 'E':
2232 avatar_action::eat( u, locThisItem );
2233 break;
2234 case 'W':
2235 u.wear( oThisItem );
2236 break;
2237 case 'w':
2238 wield( locThisItem );
2239 break;
2240 case 't':
2241 avatar_action::plthrow( u, locThisItem );
2242 break;
2243 case 'c':
2244 u.change_side( locThisItem );
2245 break;
2246 case 'T':
2247 u.takeoff( oThisItem );
2248 break;
2249 case 'd':
2250 u.drop( locThisItem, u.pos() );
2251 break;
2252 case 'U':
2253 unload( locThisItem );
2254 break;
2255 case 'r':
2256 reload( locThisItem );
2257 break;
2258 case 'p':
2259 reload( locThisItem, true );
2260 break;
2261 case 'm':
2262 avatar_action::mend( u, locThisItem );
2263 break;
2264 case 'R':
2265 u.read( locThisItem );
2266 break;
2267 case 'D':
2268 u.disassemble( locThisItem, false );
2269 break;
2270 case 'f':
2271 oThisItem.is_favorite = !oThisItem.is_favorite;
2272 break;
2273 case '=':
2274 game_menus::inv::reassign_letter( u, oThisItem );
2275 break;
2276 case KEY_PPAGE:
2277 iScrollPos -= iScrollHeight;
2278 if( ui ) {
2279 ui->invalidate_ui();
2280 }
2281 break;
2282 case KEY_NPAGE:
2283 iScrollPos += iScrollHeight;
2284 if( ui ) {
2285 ui->invalidate_ui();
2286 }
2287 break;
2288 case '+':
2289 if( !bHPR ) {
2290 get_auto_pickup().add_rule( &oThisItem );
2291 add_msg( m_info, _( "'%s' added to character pickup rules." ), oThisItem.tname( 1,
2292 false ) );
2293 }
2294 break;
2295 case '-':
2296 if( bHPR ) {
2297 get_auto_pickup().remove_rule( &oThisItem );
2298 add_msg( m_info, _( "'%s' removed from character pickup rules." ), oThisItem.tname( 1,
2299 false ) );
2300 }
2301 break;
2302 default:
2303 break;
2304 }
2305 } while( !exit );
2306 }
2307 return cMenu;
2308}
hint_rating rate_action_change_side(const item &it) const
Used to determine player feedback on item use for the inventory code.
Definition: character.cpp:3674
bool is_wielding(const item &target) const
Definition: character.cpp:3224
bool change_side(item &it, bool interactive=true)
Swap side on which item is worn; returns false on fail.
Definition: character.cpp:3687
hint_rating rate_action_eat(const item &it) const
void remove_rule(const item *it)
bool has_rule(const item *it)
void add_rule(const item *it)
hint_rating rate_action_read(const item &it) const
Definition: avatar.cpp:933
bool read(item_location loc, bool continuous=false)
Handles reading effects and returns true if activity started.
Definition: avatar.cpp:367
bool unload(item_location loc)
Definition: game.cpp:9005
void reload(item_location &loc, bool prompt=false, bool empty=true)
Definition: game.cpp:8833
bool is_favorite
Definition: item.h:2234
std::string info(bool showtext=false) const
Return all the information about the item and its type.
Definition: item.cpp:1101
std::string type_name(unsigned int quantity=1) const
Name of the item type (not the item), with proper plural.
Definition: item.cpp:9678
std::string tname(unsigned int quantity=1, bool with_prefix=true, unsigned int truncate=0) const
Return the (translated) item name.
Definition: item.cpp:4440
bool has_flag(const std::string &flag) const
Definition: item.cpp:5192
char invlet
Definition: item.h:2232
hint_rating rate_action_mend(const item &it) const
Definition: player.cpp:3296
cata::optional< std::list< item >::iterator > wear(int pos, bool interactive=true)
Wear item; returns false on fail.
Definition: player.cpp:2873
hint_rating rate_action_takeoff(const item &it) const
Definition: player.cpp:2923
hint_rating rate_action_reload(const item &it) const
Definition: player.cpp:3234
hint_rating rate_action_wear(const item &it) const
Definition: player.cpp:2638
hint_rating rate_action_disassemble(const item &it)
Definition: player.cpp:3305
hint_rating rate_action_unload(const item &it) const
Definition: player.cpp:3259
bool takeoff(item &it, std::list< item > *res=nullptr)
Takes off an item, returning false on fail.
Definition: player.cpp:2977
hint_rating rate_action_use(const item &it) const
Used to determine player feedback on item use for the inventory code.
Definition: player.cpp:3318
nc_color border_color
Definition: ui.h:328
int keypress
Definition: ui.h:413
bool filtering
Definition: ui.h:354
pos_scalar w_x_setup
Definition: ui.h:337
int fselected
Definition: ui.h:388
int selected
Definition: ui.h:415
bool allow_anykey
Definition: ui.h:360
int vshift
Definition: ui.h:386
std::vector< uilist_entry > entries
Definition: ui.h:323
bool has_item(const item &it) const
Returns true if this visitable instance contains the item.
Definition: visitable.cpp:95
static constexpr int KEY_NPAGE
Definition: input.h:65
static constexpr int KEY_PPAGE
Definition: input.h:66
static constexpr int KEY_RIGHT
Definition: input.h:40
hint_rating
Hint value used in a hack to decide text color.
Definition: item.h:2257
@ iffy
Item should display as red.
@ good
Item should display as green.
@ cant
Item should display as gray.
void reassign_letter(player &p, item &it)
input_event draw_item_info(const int iLeft, const int iWidth, const int iTop, const int iHeight, item_info_data &data)
Definition: output.cpp:793
#define BORDER_COLOR
Definition: output.h:135
const int UILIST_UNBOUND
Definition: ui.h:27
const int UILIST_WAIT_INPUT
Definition: ui.h:26

References _, add_msg(), auto_pickup::player_settings::add_rule(), uilist::addentry(), uilist::allow_anykey, BORDER_COLOR, uilist::border_color, c_light_gray, c_light_green, c_light_red, cant, Character::change_side(), player::disassemble(), draw_item_info(), Character::drop(), avatar_action::eat(), uilist::entries, uilist::filtering, uilist::fselected, get_auto_pickup(), good, item::has_flag(), visitable< T >::has_item(), auto_pickup::player_settings::has_rule(), iffy, item::info(), item::invlet, item::is_favorite, Character::is_wielding(), KEY_NPAGE, KEY_PPAGE, KEY_RIGHT, uilist::keypress, LEFT_OF_INFO, LEFT_TERMINAL_EDGE, m_info, avatar_action::mend(), catacurses::newwin(), pgettext(), avatar_action::plthrow(), Character::pos(), uilist::query(), Character::rate_action_change_side(), player::rate_action_disassemble(), Character::rate_action_eat(), player::rate_action_mend(), avatar::rate_action_read(), player::rate_action_reload(), player::rate_action_takeoff(), player::rate_action_unload(), player::rate_action_use(), player::rate_action_wear(), avatar::read(), game_menus::inv::reassign_letter(), reload(), auto_pickup::player_settings::remove_rule(), uilist::ret, RIGHT_OF_INFO, RIGHT_TERMINAL_EDGE, uilist::selected, player::takeoff(), TERMX, TERMY, item::tname(), item::type_name(), u, UILIST_UNBOUND, UILIST_WAIT_INPUT, unload(), avatar_action::use_item(), uilist::vshift, uilist::w_x_setup, uilist::w_y_setup, Character::weapon, player::wear(), wield(), and item_info_data::without_getch.

◆ is_core_data_loaded()

bool game::is_core_data_loaded ( ) const

Returns whether the core data is currently loaded.

Definition at line 431 of file game.cpp.

432{
434}
bool is_data_finalized() const
Returns whether the data is finalized and ready to be utilized.
Definition: init.h:167

References DynamicDataLoader::get_instance(), and DynamicDataLoader::is_data_finalized().

◆ is_dangerous_tile()

bool game::is_dangerous_tile ( const tripoint dest_loc) const

Definition at line 9238 of file game.cpp.

9239{
9240 return !( get_dangerous_tile( dest_loc ).empty() );
9241}
std::vector< std::string > get_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:9260

References get_dangerous_tile().

Referenced by walk_move().

◆ is_empty()

bool game::is_empty ( const tripoint p)

Returns true if there is no player, NPC, or monster on the tile and move_cost > 0.

Definition at line 5140 of file game.cpp.

5141{
5142 return ( m.passable( p ) || m.has_flag( "LIQUID", p ) ) &&
5143 critter_at( p ) == nullptr;
5144}

References critter_at(), map::has_flag(), m, and map::passable().

Referenced by grabbed_furn_move(), monmove(), place_player(), and update_stair_monsters().

◆ is_game_over()

bool game::is_game_over ( )
private

Definition at line 2678 of file game.cpp.

2679{
2680 if( uquit == QUIT_WATCH ) {
2681 // deny player movement and dodging
2682 u.moves = 0;
2683 // prevent pain from updating
2684 u.set_pain( 0 );
2685 // prevent dodging
2686 u.dodges_left = 0;
2687 return false;
2688 }
2689 if( uquit == QUIT_DIED ) {
2690 if( u.in_vehicle ) {
2691 m.unboard_vehicle( u.pos() );
2692 }
2693 u.place_corpse();
2694 return true;
2695 }
2696 if( uquit == QUIT_SUICIDE ) {
2697 if( u.in_vehicle ) {
2698 m.unboard_vehicle( u.pos() );
2699 }
2700 return true;
2701 }
2702 if( uquit != QUIT_NO ) {
2703 return true;
2704 }
2705 // is_dead_state() already checks hp_torso && hp_head, no need to for loop it
2706 if( u.is_dead_state() ) {
2708 if( get_option<std::string>( "DEATHCAM" ) == "always" ) {
2709 uquit = QUIT_WATCH;
2710 } else if( get_option<std::string>( "DEATHCAM" ) == "ask" ) {
2711 uquit = query_yn( _( "Watch the last moments of your life…?" ) ) ?
2713 } else if( get_option<std::string>( "DEATHCAM" ) == "never" ) {
2714 uquit = QUIT_DIED;
2715 } else {
2716 // Something funky happened here, just die.
2717 dbg( DL::Error ) << "no deathcam option given to options, defaulting to QUIT_DIED";
2718 uquit = QUIT_DIED;
2719 }
2720 return is_game_over();
2721 }
2722 return false;
2723}
int dodges_left
Definition: character.h:616
void set_pain(int npain) override
Sets new intensity of pain an reacts to it.
Definition: player.cpp:1119
@ Error
Error (default: enabled).
#define dbg(x)
Definition: game.cpp:187
void deactivate()
Definition: messages.cpp:357

References _, dbg, Messages::deactivate(), Character::dodges_left, Error, Character::in_vehicle, player::is_dead_state(), is_game_over(), m, Creature::moves, Character::place_corpse(), Character::pos(), query_yn(), QUIT_DIED, QUIT_NO, QUIT_SUICIDE, QUIT_WATCH, player::set_pain(), u, map::unboard_vehicle(), and uquit.

Referenced by do_turn(), and is_game_over().

◆ is_hostile_nearby()

Creature * game::is_hostile_nearby ( )

Definition at line 3937 of file game.cpp.

3938{
3939 int distance = ( get_option<int>( "SAFEMODEPROXIMITY" ) <= 0 ) ? MAX_VIEW_DISTANCE :
3940 get_option<int>( "SAFEMODEPROXIMITY" );
3941 return is_hostile_within( distance );
3942}
Creature * is_hostile_within(int distance)
Definition: game.cpp:3949

References is_hostile_within(), and MAX_VIEW_DISTANCE.

◆ is_hostile_very_close()

Creature * game::is_hostile_very_close ( )

Definition at line 3944 of file game.cpp.

3945{
3947}
static constexpr int DANGEROUS_PROXIMITY
Definition: game.cpp:189

References DANGEROUS_PROXIMITY, and is_hostile_within().

Referenced by butcher(), and process_voluntary_act_interrupt().

◆ is_hostile_within()

Creature * game::is_hostile_within ( int  distance)
private

Definition at line 3949 of file game.cpp.

3950{
3951 for( auto &critter : u.get_visible_creatures( distance ) ) {
3952 if( u.attitude_to( *critter ) == Creature::A_HOSTILE ) {
3953 return critter;
3954 }
3955 }
3956
3957 return nullptr;
3958}
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
std::vector< Creature * > get_visible_creatures(int range) const
Returns all creatures that this player can see and that are in the given range.
@ A_HOSTILE
Definition: creature.h:169

References Creature::A_HOSTILE, Character::attitude_to(), Character::get_visible_creatures(), and u.

Referenced by is_hostile_nearby(), and is_hostile_very_close().

◆ is_in_sunlight()

bool game::is_in_sunlight ( const tripoint p)

Returns true if p is outdoors and it is sunny.

Definition at line 5146 of file game.cpp.

5147{
5148 return weather::is_in_sunlight( m, p, get_weather().weather_id );
5149}
bool is_in_sunlight(const map &m, const tripoint &p, const weather_type_id &weather)
Definition: weather.cpp:1162

References get_weather, weather::is_in_sunlight(), and m.

Referenced by process_artifact().

◆ is_in_viewport()

bool game::is_in_viewport ( const tripoint p,
int  margin = 0 
) const

Definition at line 3583 of file game.cpp.

3584{
3585 const tripoint diff( u.pos() + u.view_offset - p );
3586
3587 return ( std::abs( diff.x ) <= getmaxx( w_terrain ) / 2 - margin ) &&
3588 ( std::abs( diff.y ) <= getmaxy( w_terrain ) / 2 - margin );
3589}

References catacurses::getmaxx(), catacurses::getmaxy(), Character::pos(), u, player::view_offset, w_terrain, tripoint::x, and tripoint::y.

◆ is_sheltered()

bool game::is_sheltered ( const tripoint p)

Returns true if p is indoors, underground, or in a car.

Definition at line 5151 of file game.cpp.

5152{
5153 return weather::is_sheltered( m, p );
5154}
bool is_sheltered(const map &m, const tripoint &p)
Definition: weather.cpp:1153

References weather::is_sheltered(), and m.

◆ is_zones_manager_open()

bool game::is_zones_manager_open ( ) const

Definition at line 6294 of file game.cpp.

6295{
6296 return zones_manager_open;
6297}
bool zones_manager_open
Is Zone manager open or not - changes graphics of some zone tiles.
Definition: game.h:1101

References zones_manager_open.

◆ item_action_menu()

void game::item_action_menu ( )
private

Definition at line 231 of file item_action.cpp.

232{
233 const auto &gen = item_action_generator::generator();
234 const action_map &item_actions = gen.get_item_action_map();
235
236 // HACK: A bit of a hack for now. If more pseudos get implemented, this should be un-hacked
237 std::vector<item *> pseudos;
238 item toolset( "toolset", calendar::turn );
239 if( u.has_active_bionic( bio_tools ) ) {
240 pseudos.push_back( &toolset );
241 }
242 item bio_claws_item( static_cast<std::string>( bio_claws_weapon ), calendar::turn );
243 if( u.has_active_bionic( bio_claws ) ) {
244 pseudos.push_back( &bio_claws_item );
245 }
246
247 item_action_map iactions = gen.map_actions_to_items( u, pseudos );
248 if( iactions.empty() ) {
249 popup( _( "You don't have any items with registered uses" ) );
250 }
251
252 uilist kmenu;
253 kmenu.text = _( "Execute which action?" );
254 kmenu.input_category = "ITEM_ACTIONS";
255 input_context ctxt( "ITEM_ACTIONS" );
256 for( const auto &id : item_actions ) {
257 ctxt.register_action( id.first, id.second.name );
258 kmenu.additional_actions.emplace_back( id.first, id.second.name );
259 }
260 actmenu_cb callback( item_actions );
261 kmenu.callback = &callback;
262 int num = 0;
263
264 const auto assigned_action = [&iactions]( const item_action_id & action ) {
265 return iactions.find( action ) != iactions.end();
266 };
267
268 std::vector<std::tuple<item_action_id, std::string, std::string>> menu_items;
269 // Sorts menu items by action.
270 using Iter = decltype( menu_items )::iterator;
271 const auto sort_menu = []( Iter from, Iter to ) {
272 std::sort( from, to, []( const std::tuple<item_action_id, std::string, std::string> &lhs,
273 const std::tuple<item_action_id, std::string, std::string> &rhs ) {
274 return std::get<1>( lhs ).compare( std::get<1>( rhs ) ) < 0;
275 } );
276 };
277 // Add mapped actions to the menu vector.
278 std::transform( iactions.begin(), iactions.end(), std::back_inserter( menu_items ),
279 []( const std::pair<item_action_id, item *> &elem ) {
280 std::string ss = elem.second->display_name();
281 if( elem.second->ammo_required() ) {
282 ss += string_format( " (%d/%d)", elem.second->ammo_required(), elem.second->ammo_remaining() );
283 }
284
285 const auto method = elem.second->get_use( elem.first );
286 if( method ) {
287 return std::make_tuple( method->get_type(), method->get_name(), ss );
288 } else {
289 return std::make_tuple( errstring, std::string( "NO USE FUNCTION" ), ss );
290 }
291 } );
292 // Sort mapped actions.
293 sort_menu( menu_items.begin(), menu_items.end() );
294 // Add unmapped but binded actions to the menu vector.
295 for( const auto &elem : item_actions ) {
296 if( key_bound_to( ctxt, elem.first ) != '\0' && !assigned_action( elem.first ) ) {
297 menu_items.emplace_back( elem.first, gen.get_action_name( elem.first ), "-" );
298 }
299 }
300 // Sort unmapped actions.
301 auto iter = menu_items.begin();
302 std::advance( iter, iactions.size() );
303 sort_menu( iter, menu_items.end() );
304 // Determine max lengths, to print the menu nicely.
305 std::pair<int, int> max_len;
306 for( const auto &elem : menu_items ) {
307 max_len.first = std::max( max_len.first, utf8_width( std::get<1>( elem ), true ) );
308 max_len.second = std::max( max_len.second, utf8_width( std::get<2>( elem ), true ) );
309 }
310 // Fill the menu.
311 for( const auto &elem : menu_items ) {
312 std::string ss;
313 ss += std::get<1>( elem );
314 ss += std::string( max_len.first - utf8_width( std::get<1>( elem ), true ), ' ' );
315 ss += std::string( 4, ' ' );
316
317 ss += std::get<2>( elem );
318 ss += std::string( max_len.second - utf8_width( std::get<2>( elem ), true ), ' ' );
319
320 const char bind = key_bound_to( ctxt, std::get<0>( elem ) );
321 const bool enabled = assigned_action( std::get<0>( elem ) );
322
323 kmenu.addentry( num, enabled, bind, ss );
324 num++;
325 }
326
327 kmenu.query();
328 if( kmenu.ret < 0 || kmenu.ret >= static_cast<int>( iactions.size() ) ) {
329 return;
330 }
331
332 const item_action_id action = std::get<0>( menu_items[kmenu.ret] );
333 item *it = iactions[action];
334
335 u.invoke_item( it, action );
336
337 u.inv.restack( u );
338 u.inv.unsort();
339}
inventory inv
Definition: character.h:1583
bool invoke_item(item *, const tripoint &pt) override
Asks how to use the item (if it has more than one use_method) and uses it.
Definition: avatar.cpp:1267
void restack(player &p)
Definition: inventory.cpp:398
void unsort()
Definition: inventory.cpp:226
static item_action_generator & generator()
Definition: item_action.h:32
std::string input_category
Definition: ui.h:325
std::vector< std::pair< std::string, translation > > additional_actions
Definition: ui.h:326
static char key_bound_to(const input_context &ctxt, const item_action_id &act)
Definition: item_action.cpp:47
static const bionic_id bio_claws("bio_claws")
static const bionic_id bio_tools("bio_tools")
static const bionic_id bio_claws_weapon("bio_claws_weapon")
std::string item_action_id
Definition: item_action.h:16
std::map< item_action_id, item_action > action_map
Definition: item_action.h:18
std::map< item_action_id, item * > item_action_map
Definition: item_action.h:17

References _, action, uilist::additional_actions, bio_claws, bio_claws_weapon, bio_tools, uilist::callback, item_action_generator::generator(), Character::has_active_bionic(), uilist::input_category, num, popup(), input_context::register_action(), second, uilist::text, iexamine::transform(), calendar::turn, and u.

Referenced by handle_action().

◆ knockback() [1/2]

void game::knockback ( const tripoint s,
const tripoint t,
int  force,
int  stun,
int  dam_mult 
)

Definition at line 4573 of file game.cpp.

4574{
4575 std::vector<tripoint> traj;
4576 traj.clear();
4577 traj = line_to( s, t, 0, 0 );
4578 traj.insert( traj.begin(), s ); // how annoying, line_to() doesn't include the originating point!
4579 traj = continue_line( traj, force );
4580 traj.insert( traj.begin(), t ); // how annoying, continue_line() doesn't either!
4581
4582 knockback( traj, stun, dam_mult );
4583}
std::vector< coords::coord_point< Point, Origin, Scale > > line_to(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:548
std::vector< tripoint > continue_line(const std::vector< tripoint > &line, const int distance)
Definition: line.cpp:408

References continue_line(), knockback(), and line_to().

Referenced by forced_door_closing(), and knockback().

◆ knockback() [2/2]

void game::knockback ( std::vector< tripoint > &  traj,
int  stun,
int  dam_mult 
)

Definition at line 4589 of file game.cpp.

4590{
4591 // TODO: make the force parameter actually do something.
4592 // the header file says higher force causes more damage.
4593 // perhaps that is what it should do?
4594 tripoint tp = traj.front();
4595 if( !critter_at( tp ) ) {
4596 debugmsg( _( "Nothing at (%d,%d,%d) to knockback!" ), tp.x, tp.y, tp.z );
4597 return;
4598 }
4599 std::size_t force_remaining = traj.size();
4600 if( monster *const targ = critter_at<monster>( tp, true ) ) {
4601 if( stun > 0 ) {
4602 targ->add_effect( effect_stunned, 1_turns * stun );
4603 add_msg( _( "%s was stunned!" ), targ->name() );
4604 }
4605 for( size_t i = 1; i < traj.size(); i++ ) {
4606 if( m.impassable( traj[i].xy() ) ) {
4607 targ->setpos( traj[i - 1] );
4608 force_remaining = traj.size() - i;
4609 if( stun != 0 ) {
4610 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4611 add_msg( _( "%s was stunned!" ), targ->name() );
4612 add_msg( _( "%s slammed into an obstacle!" ), targ->name() );
4613 targ->apply_damage( nullptr, bodypart_id( "torso" ), dam_mult * force_remaining );
4614 targ->check_dead_state();
4615 }
4616 m.bash( traj[i], 2 * dam_mult * force_remaining );
4617 break;
4618 } else if( critter_at( traj[i] ) ) {
4619 targ->setpos( traj[i - 1] );
4620 force_remaining = traj.size() - i;
4621 if( stun != 0 ) {
4622 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4623 add_msg( _( "%s was stunned!" ), targ->name() );
4624 }
4625 traj.erase( traj.begin(), traj.begin() + i );
4626 if( critter_at<monster>( traj.front() ) ) {
4627 add_msg( _( "%s collided with something else and sent it flying!" ),
4628 targ->name() );
4629 } else if( npc *const guy = critter_at<npc>( traj.front() ) ) {
4630 if( guy->male ) {
4631 add_msg( _( "%s collided with someone else and sent him flying!" ),
4632 targ->name() );
4633 } else {
4634 add_msg( _( "%s collided with someone else and sent her flying!" ),
4635 targ->name() );
4636 }
4637 } else if( u.pos() == traj.front() ) {
4638 add_msg( m_bad, _( "%s collided with you and sent you flying!" ), targ->name() );
4639 }
4640 knockback( traj, stun, dam_mult );
4641 break;
4642 }
4643 targ->setpos( traj[i] );
4644 if( m.has_flag( "LIQUID", targ->pos() ) && !targ->can_drown() && !targ->is_dead() ) {
4645 targ->die( nullptr );
4646 if( u.sees( *targ ) ) {
4647 add_msg( _( "The %s drowns!" ), targ->name() );
4648 }
4649 }
4650 if( !m.has_flag( "LIQUID", targ->pos() ) && targ->has_flag( MF_AQUATIC ) &&
4651 !targ->is_dead() ) {
4652 targ->die( nullptr );
4653 if( u.sees( *targ ) ) {
4654 add_msg( _( "The %s flops around and dies!" ), targ->name() );
4655 }
4656 }
4657 }
4658 } else if( npc *const targ = critter_at<npc>( tp ) ) {
4659 if( stun > 0 ) {
4660 targ->add_effect( effect_stunned, 1_turns * stun );
4661 add_msg( _( "%s was stunned!" ), targ->name );
4662 }
4663 for( size_t i = 1; i < traj.size(); i++ ) {
4664 if( m.impassable( traj[i].xy() ) ) { // oops, we hit a wall!
4665 targ->setpos( traj[i - 1] );
4666 force_remaining = traj.size() - i;
4667 if( stun != 0 ) {
4668 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4669 if( targ->has_effect( effect_stunned ) ) {
4670 add_msg( _( "%s was stunned!" ), targ->name );
4671 }
4672
4673 std::array<bodypart_id, 8> bps = {{
4674 bodypart_id( "head" ),
4675 bodypart_id( "arm_l" ), bodypart_id( "arm_r" ),
4676 bodypart_id( "hand_l" ), bodypart_id( "hand_r" ),
4677 bodypart_id( "torso" ),
4678 bodypart_id( "leg_l" ), bodypart_id( "leg_r" )
4679 }
4680 };
4681 for( const bodypart_id &bp : bps ) {
4682 if( one_in( 2 ) ) {
4683 targ->deal_damage( nullptr, bp, damage_instance( DT_BASH, force_remaining * dam_mult ) );
4684 }
4685 }
4686 targ->check_dead_state();
4687 }
4688 m.bash( traj[i], 2 * dam_mult * force_remaining );
4689 break;
4690 } else if( critter_at( traj[i] ) ) {
4691 targ->setpos( traj[i - 1] );
4692 force_remaining = traj.size() - i;
4693 if( stun != 0 ) {
4694 add_msg( _( "%s was stunned!" ), targ->name );
4695 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4696 }
4697 traj.erase( traj.begin(), traj.begin() + i );
4698 const tripoint &traj_front = traj.front();
4699 if( critter_at<monster>( traj_front ) ) {
4700 add_msg( _( "%s collided with something else and sent it flying!" ),
4701 targ->name );
4702 } else if( npc *const guy = critter_at<npc>( traj_front ) ) {
4703 if( guy->male ) {
4704 add_msg( _( "%s collided with someone else and sent him flying!" ),
4705 targ->name );
4706 } else {
4707 add_msg( _( "%s collided with someone else and sent her flying!" ),
4708 targ->name );
4709 }
4710 } else if( u.posx() == traj_front.x && u.posy() == traj_front.y &&
4712 ( u.footwear_factor() == .5 && one_in( 2 ) ) ) ) ) {
4713 add_msg( _( "%s collided with you, and barely dislodges your tentacles!" ), targ->name );
4714 } else if( u.posx() == traj_front.x && u.posy() == traj_front.y ) {
4715 add_msg( m_bad, _( "%s collided with you and sent you flying!" ), targ->name );
4716 }
4717 knockback( traj, stun, dam_mult );
4718 break;
4719 }
4720 targ->setpos( traj[i] );
4721 }
4722 } else if( u.pos() == tp ) {
4723 if( stun > 0 ) {
4724 u.add_effect( effect_stunned, 1_turns * stun );
4725 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4726 "You were stunned for %d turns!",
4727 stun ),
4728 stun );
4729 }
4730 for( size_t i = 1; i < traj.size(); i++ ) {
4731 if( m.impassable( traj[i] ) ) { // oops, we hit a wall!
4732 u.setpos( traj[i - 1] );
4733 force_remaining = traj.size() - i;
4734 if( stun != 0 ) {
4735 if( u.has_effect( effect_stunned ) ) {
4736 add_msg( m_bad, vgettext( "You were stunned AGAIN for %d turn!",
4737 "You were stunned AGAIN for %d turns!",
4738 force_remaining ),
4739 force_remaining );
4740 } else {
4741 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4742 "You were stunned for %d turns!",
4743 force_remaining ),
4744 force_remaining );
4745 }
4746 u.add_effect( effect_stunned, 1_turns * force_remaining );
4747 std::array<bodypart_id, 8> bps = {{
4748 bodypart_id( "head" ),
4749 bodypart_id( "arm_l" ), bodypart_id( "arm_r" ),
4750 bodypart_id( "hand_l" ), bodypart_id( "hand_r" ),
4751 bodypart_id( "torso" ),
4752 bodypart_id( "leg_l" ), bodypart_id( "leg_r" )
4753 }
4754 };
4755 for( const bodypart_id &bp : bps ) {
4756 if( one_in( 2 ) ) {
4757 u.deal_damage( nullptr, bp, damage_instance( DT_BASH, force_remaining * dam_mult ) );
4758 }
4759 }
4761 }
4762 m.bash( traj[i], 2 * dam_mult * force_remaining );
4763 break;
4764 } else if( critter_at( traj[i] ) ) {
4765 u.setpos( traj[i - 1] );
4766 force_remaining = traj.size() - i;
4767 if( stun != 0 ) {
4768 if( u.has_effect( effect_stunned ) ) {
4769 add_msg( m_bad, vgettext( "You were stunned AGAIN for %d turn!",
4770 "You were stunned AGAIN for %d turns!",
4771 force_remaining ),
4772 force_remaining );
4773 } else {
4774 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4775 "You were stunned for %d turns!",
4776 force_remaining ),
4777 force_remaining );
4778 }
4779 u.add_effect( effect_stunned, 1_turns * force_remaining );
4780 }
4781 traj.erase( traj.begin(), traj.begin() + i );
4782 if( critter_at<monster>( traj.front() ) ) {
4783 add_msg( _( "You collided with something and sent it flying!" ) );
4784 } else if( npc *const guy = critter_at<npc>( traj.front() ) ) {
4785 if( guy->male ) {
4786 add_msg( _( "You collided with someone and sent him flying!" ) );
4787 } else {
4788 add_msg( _( "You collided with someone and sent her flying!" ) );
4789 }
4790 }
4791 knockback( traj, stun, dam_mult );
4792 break;
4793 }
4794 if( m.has_flag( "LIQUID", u.pos() ) && force_remaining == 0 ) {
4795 avatar_action::swim( m, u, u.pos() );
4796 } else {
4797 u.setpos( traj[i] );
4798 }
4799 }
4800 }
4801}
double footwear_factor() const
Returns 1 if the player is wearing something on both feet, .5 if on one, and 0 if on neither.
Definition: character.cpp:8926
dealt_damage_instance deal_damage(Creature *source, bodypart_id bp, const damage_instance &d) override
Calls Creature::deal_damage and handles damaged effects (waking up, etc.)
Definition: character.cpp:8450
void add_effect(const effect &eff, bool force=false, bool deferred=false)
Definition: creature.cpp:977
@ DT_BASH
Definition: damage.h:24
static const trait_id trait_LEG_TENT_BRACE("LEG_TENT_BRACE")
static const efftype_id effect_stunned("stunned")
@ MF_AQUATIC
Definition: mtype.h:89
void swim(map &m, avatar &you, const tripoint &p)
Handles swimming by the player.
const char * vgettext(const char *msgid, const char *msgid_plural, size_t n)

References _, Creature::add_effect(), add_msg(), map::bash(), Creature::check_dead_state(), critter_at(), Character::deal_damage(), debugmsg, DT_BASH, effect_stunned, Character::footwear_factor(), Creature::has_effect(), map::has_flag(), Character::has_trait(), map::impassable(), knockback(), m, m_bad, MF_AQUATIC, one_in(), Character::pos(), Character::posx(), Character::posy(), Character::sees(), Character::setpos(), avatar_action::swim(), trait_LEG_TENT_BRACE, u, vgettext(), tripoint::x, tripoint::y, and tripoint::z.

◆ light_level()

unsigned char game::light_level ( int  zlev) const

Returns coarse number-of-squares of visibility at the current light level.

Used by monster and NPC AI.

Definition at line 3916 of file game.cpp.

3917{
3918 const float light = natural_light_level( zlev );
3919 return LIGHT_RANGE( light );
3920}
float natural_light_level(int zlev) const
Definition: game.cpp:3856
#define LIGHT_RANGE(b)
Definition: lightmap.h:41

References light, LIGHT_RANGE, and natural_light_level().

Referenced by calc_driving_offset(), and update_overmap_seen().

◆ list_active_characters()

std::vector< std::string > game::list_active_characters ( )

Returns a list of currently active character saves.

Definition at line 3123 of file game.cpp.

3124{
3125 std::vector<std::string> saves;
3126 for( auto &worldsave : world_generator->active_world->world_saves ) {
3127 saves.push_back( worldsave.player_name() );
3128 }
3129 return saves;
3130}

References world_generator.

Referenced by cleanup_at_end().

◆ list_items()

game::vmenu_ret game::list_items ( const std::vector< map_item_stack > &  item_list)
private

Definition at line 7528 of file game.cpp.

7529{
7530 std::vector<map_item_stack> ground_items = item_list;
7531 int iInfoHeight = 0;
7532 int iMaxRows = 0;
7533 int width = 0;
7534 int max_name_width = 0;
7535
7536 //find max length of item name and resize window width
7537 for( const map_item_stack &cur_item : ground_items ) {
7538 const int item_len = utf8_width( remove_color_tags( cur_item.example->display_name() ) ) + 15;
7539 if( item_len > max_name_width ) {
7540 max_name_width = item_len;
7541 }
7542 }
7543
7544 tripoint active_pos;
7545 map_item_stack *activeItem = nullptr;
7546
7547 catacurses::window w_items;
7548 catacurses::window w_items_border;
7549 catacurses::window w_item_info;
7550
7551 ui_adaptor ui;
7552 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
7553 iInfoHeight = std::min( 25, TERMY / 2 );
7554 iMaxRows = TERMY - iInfoHeight - 2;
7555
7556 width = clamp( max_name_width, 45, TERMX / 3 );
7557
7558 const int offsetX = TERMX - width;
7559
7560 w_items = catacurses::newwin( TERMY - 2 - iInfoHeight,
7561 width - 2, point( offsetX + 1, 1 ) );
7562 w_items_border = catacurses::newwin( TERMY - iInfoHeight,
7563 width, point( offsetX, 0 ) );
7564 w_item_info = catacurses::newwin( iInfoHeight, width,
7565 point( offsetX, TERMY - iInfoHeight ) );
7566
7567 if( activeItem ) {
7568 centerlistview( active_pos, width );
7569 }
7570
7571 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
7572 } );
7573 ui.mark_resize();
7574
7575 // use previously selected sorting method
7576 bool sort_radius = uistate.list_item_sort != 2;
7577 bool addcategory = !sort_radius;
7578
7579 // reload filter/priority settings on the first invocation, if they were active
7580 if( !uistate.list_item_init ) {
7583 }
7586 }
7589 }
7590 uistate.list_item_init = true;
7591 }
7592
7593 //this stores only those items that match our filter
7594 std::vector<map_item_stack> filtered_items =
7595 !sFilter.empty() ? filter_item_stacks( ground_items, sFilter ) : ground_items;
7596 int highPEnd = list_filter_high_priority( filtered_items, list_item_upvote );
7597 int lowPStart = list_filter_low_priority( filtered_items, highPEnd, list_item_downvote );
7598 int iItemNum = ground_items.size();
7599
7600 const tripoint stored_view_offset = u.view_offset;
7601
7603
7604 int iActive = 0; // Item index that we're looking at
7605 bool refilter = true;
7606 int page_num = 0;
7607 int iCatSortNum = 0;
7608 int iScrollPos = 0;
7609 std::map<int, std::string> mSortCategory;
7610
7611 std::string action;
7612 input_context ctxt( "LIST_ITEMS" );
7613 ctxt.register_action( "UP", to_translation( "Move cursor up" ) );
7614 ctxt.register_action( "DOWN", to_translation( "Move cursor down" ) );
7615 ctxt.register_action( "LEFT", to_translation( "Previous item" ) );
7616 ctxt.register_action( "RIGHT", to_translation( "Next item" ) );
7617 ctxt.register_action( "PAGE_DOWN" );
7618 ctxt.register_action( "PAGE_UP" );
7619 ctxt.register_action( "NEXT_TAB" );
7620 ctxt.register_action( "PREV_TAB" );
7621 ctxt.register_action( "HELP_KEYBINDINGS" );
7622 ctxt.register_action( "QUIT" );
7623 ctxt.register_action( "FILTER" );
7624 ctxt.register_action( "RESET_FILTER" );
7625 ctxt.register_action( "EXAMINE" );
7626 ctxt.register_action( "COMPARE" );
7627 ctxt.register_action( "PRIORITY_INCREASE" );
7628 ctxt.register_action( "PRIORITY_DECREASE" );
7629 ctxt.register_action( "SORT" );
7630 ctxt.register_action( "TRAVEL_TO" );
7631
7633
7634 ui.on_redraw( [&]( const ui_adaptor & ) {
7635 reset_item_list_state( w_items_border, iInfoHeight, sort_radius );
7636
7637 if( ground_items.empty() ) {
7638 wnoutrefresh( w_items_border );
7639 mvwprintz( w_items, point( 2, 10 ), c_white, _( "You don't see any items around you!" ) );
7640 } else {
7641 int iStartPos = 0;
7642 werase( w_items );
7643 calcStartPos( iStartPos, iActive, iMaxRows, iItemNum );
7644 int iNum = 0;
7645 bool high = false;
7646 bool low = false;
7647 int index = 0;
7648 int iCatSortOffset = 0;
7649
7650 for( int i = 0; i < iStartPos; i++ ) {
7651 if( !mSortCategory[i].empty() ) {
7652 iNum++;
7653 }
7654 }
7655 for( auto iter = filtered_items.begin(); iter != filtered_items.end(); ++index ) {
7656 if( highPEnd > 0 && index < highPEnd + iCatSortOffset ) {
7657 high = true;
7658 low = false;
7659 } else if( index >= lowPStart + iCatSortOffset ) {
7660 high = false;
7661 low = true;
7662 } else {
7663 high = false;
7664 low = false;
7665 }
7666
7667 if( iNum >= iStartPos && iNum < iStartPos + ( iMaxRows > iItemNum ? iItemNum : iMaxRows ) ) {
7668 int iThisPage = 0;
7669 if( !mSortCategory[iNum].empty() ) {
7670 iCatSortOffset++;
7671 mvwprintz( w_items, point( 1, iNum - iStartPos ), c_magenta, mSortCategory[iNum] );
7672 } else {
7673 if( iNum == iActive ) {
7674 iThisPage = page_num;
7675 }
7676 std::string sText;
7677 if( iter->vIG.size() > 1 ) {
7678 sText += string_format( "[%d/%d] (%d) ", iThisPage + 1, iter->vIG.size(), iter->totalcount );
7679 }
7680 sText += iter->example->tname();
7681 if( iter->vIG[iThisPage].count > 1 ) {
7682 sText += string_format( "[%d]", iter->vIG[iThisPage].count );
7683 }
7684
7685 nc_color col = c_light_green;
7686 if( iNum != iActive ) {
7687 if( high ) {
7688 col = c_yellow;
7689 } else if( low ) {
7690 col = c_red;
7691 } else {
7692 col = iter->example->color_in_inventory();
7693 }
7694 }
7695 trim_and_print( w_items, point( 1, iNum - iStartPos ), width - 9, col, sText );
7696 const int numw = iItemNum > 9 ? 2 : 1;
7697 const int x = iter->vIG[iThisPage].pos.x;
7698 const int y = iter->vIG[iThisPage].pos.y;
7699 mvwprintz( w_items, point( width - 6 - numw, iNum - iStartPos ),
7700 iNum == iActive ? c_light_green : c_light_gray,
7701 "%*d %s", numw, rl_dist( point_zero, point( x, y ) ),
7703 ++iter;
7704 }
7705 } else {
7706 ++iter;
7707 }
7708 iNum++;
7709 }
7710 iNum = 0;
7711 for( int i = 0; i < iActive; i++ ) {
7712 if( !mSortCategory[i].empty() ) {
7713 iNum++;
7714 }
7715 }
7716 mvwprintz( w_items_border, point( ( width - 9 ) / 2 + ( iItemNum > 9 ? 0 : 1 ), 0 ),
7717 c_light_green, " %*d", iItemNum > 9 ? 2 : 1, iItemNum > 0 ? iActive - iNum + 1 : 0 );
7718 wprintz( w_items_border, c_white, " / %*d ", iItemNum > 9 ? 2 : 1, iItemNum - iCatSortNum );
7719 werase( w_item_info );
7720
7721 if( iItemNum > 0 && activeItem ) {
7722 std::vector<iteminfo> vThisItem;
7723 std::vector<iteminfo> vDummy;
7724 activeItem->example->info( true, vThisItem );
7725
7726 item_info_data dummy( "", "", vThisItem, vDummy, iScrollPos );
7727 dummy.without_getch = true;
7728 dummy.without_border = true;
7729
7730 draw_item_info( w_item_info, dummy );
7731 }
7732 draw_scrollbar( w_items_border, iActive, iMaxRows, iItemNum, point_south );
7733 wnoutrefresh( w_items_border );
7734 }
7735
7736 const bool bDrawLeft = ground_items.empty() || filtered_items.empty() || !activeItem || filter_type;
7737 draw_custom_border( w_item_info, bDrawLeft, true, true, true, LINE_XXXO, LINE_XOXX, true, true );
7738
7739 if( iItemNum > 0 && activeItem ) {
7740 // print info window title: < item name >
7741 mvwprintw( w_item_info, point( 2, 0 ), "< " );
7742 trim_and_print( w_item_info, point( 4, 0 ), width - 8, activeItem->example->color_in_inventory(),
7743 activeItem->example->display_name() );
7744 wprintw( w_item_info, " >" );
7745 }
7746
7747 wnoutrefresh( w_items );
7748 wnoutrefresh( w_item_info );
7749
7750 if( filter_type ) {
7751 draw_item_filter_rules( w_item_info, 0, iInfoHeight - 1, filter_type.value() );
7752 }
7753 } );
7754
7755 cata::optional<tripoint> trail_start;
7756 cata::optional<tripoint> trail_end;
7757 bool trail_end_x = false;
7758 shared_ptr_fast<draw_callback_t> trail_cb = create_trail_callback( trail_start, trail_end,
7759 trail_end_x );
7760 add_draw_callback( trail_cb );
7761
7762 do {
7763 if( action == "COMPARE" && activeItem ) {
7764 game_menus::inv::compare( u, active_pos );
7765 } else if( action == "FILTER" ) {
7766 filter_type = item_filter_type::FILTER;
7767 ui.invalidate_ui();
7769 .title( _( "Filter:" ) )
7770 .width( 55 )
7771 .description( _( "UP: history, CTRL-U: clear line, ESC: abort, ENTER: save" ) )
7772 .identifier( "item_filter" )
7773 .max_length( 256 )
7774 .edit( sFilter );
7775 refilter = true;
7776 addcategory = !sort_radius;
7778 filter_type = cata::nullopt;
7779 } else if( action == "RESET_FILTER" ) {
7780 sFilter.clear();
7781 filtered_items = ground_items;
7782 refilter = true;
7784 addcategory = !sort_radius;
7785 } else if( action == "EXAMINE" && !filtered_items.empty() && activeItem ) {
7786 std::vector<iteminfo> vThisItem;
7787 std::vector<iteminfo> vDummy;
7788 activeItem->example->info( true, vThisItem );
7789
7790 item_info_data info_data( activeItem->example->tname(), activeItem->example->type_name(), vThisItem,
7791 vDummy );
7792 info_data.handle_scrolling = true;
7793
7795 return catacurses::newwin( TERMY, width - 5, point_zero );
7796 }, info_data );
7797 } else if( action == "PRIORITY_INCREASE" ) {
7798 filter_type = item_filter_type::HIGH_PRIORITY;
7799 ui.invalidate_ui();
7801 .title( _( "High Priority:" ) )
7802 .width( 55 )
7804 .description( _( "UP: history, CTRL-U clear line, ESC: abort, ENTER: save" ) )
7805 .identifier( "list_item_priority" )
7806 .max_length( 256 )
7807 .query_string();
7808 refilter = true;
7809 addcategory = !sort_radius;
7811 filter_type = cata::nullopt;
7812 } else if( action == "PRIORITY_DECREASE" ) {
7813 filter_type = item_filter_type::LOW_PRIORITY;
7814 ui.invalidate_ui();
7816 .title( _( "Low Priority:" ) )
7817 .width( 55 )
7819 .description( _( "UP: history, CTRL-U clear line, ESC: abort, ENTER: save" ) )
7820 .identifier( "list_item_downvote" )
7821 .max_length( 256 )
7822 .query_string();
7823 refilter = true;
7824 addcategory = !sort_radius;
7826 filter_type = cata::nullopt;
7827 } else if( action == "SORT" ) {
7828 if( sort_radius ) {
7829 sort_radius = false;
7830 addcategory = true;
7831 uistate.list_item_sort = 2; // list is sorted by category
7832 } else {
7833 sort_radius = true;
7834 uistate.list_item_sort = 1; // list is sorted by distance
7835 }
7836 highPEnd = -1;
7837 lowPStart = -1;
7838 iCatSortNum = 0;
7839
7840 mSortCategory.clear();
7841 refilter = true;
7842 } else if( action == "TRAVEL_TO" && activeItem ) {
7843 if( !u.sees( u.pos() + active_pos ) ) {
7844 add_msg( _( "You can't see that destination." ) );
7845 }
7846 auto route = m.route( u.pos(), u.pos() + active_pos, u.get_pathfinding_settings(),
7847 u.get_path_avoid() );
7848 if( route.size() > 1 ) {
7849 route.pop_back();
7850 u.set_destination( route );
7851 break;
7852 } else {
7853 add_msg( m_info, _( "You can't travel there." ) );
7854 }
7855 }
7856 if( uistate.list_item_sort == 1 ) {
7857 ground_items = item_list;
7858 } else if( uistate.list_item_sort == 2 ) {
7859 std::sort( ground_items.begin(), ground_items.end(), map_item_stack::map_item_stack_sort );
7860 }
7861
7862 if( refilter ) {
7863 refilter = false;
7864 filtered_items = filter_item_stacks( ground_items, sFilter );
7865 highPEnd = list_filter_high_priority( filtered_items, list_item_upvote );
7866 lowPStart = list_filter_low_priority( filtered_items, highPEnd, list_item_downvote );
7867 iActive = 0;
7868 page_num = 0;
7869 iItemNum = filtered_items.size();
7870 }
7871
7872 if( addcategory ) {
7873 addcategory = false;
7874 iCatSortNum = 0;
7875 mSortCategory.clear();
7876 if( highPEnd > 0 ) {
7877 mSortCategory[0] = _( "HIGH PRIORITY" );
7878 iCatSortNum++;
7879 }
7880 std::string last_cat_name;
7881 for( int i = std::max( 0, highPEnd );
7882 i < std::min( lowPStart, static_cast<int>( filtered_items.size() ) ); i++ ) {
7883 const std::string &cat_name = filtered_items[i].example->get_category().name();
7884 if( cat_name != last_cat_name ) {
7885 mSortCategory[i + iCatSortNum++] = cat_name;
7886 last_cat_name = cat_name;
7887 }
7888 }
7889 if( lowPStart < static_cast<int>( filtered_items.size() ) ) {
7890 mSortCategory[lowPStart + iCatSortNum++] = _( "LOW PRIORITY" );
7891 }
7892 if( !mSortCategory[0].empty() ) {
7893 iActive++;
7894 }
7895 iItemNum = static_cast<int>( filtered_items.size() ) + iCatSortNum;
7896 }
7897
7898 if( action == "UP" ) {
7899 do {
7900 iActive--;
7901
7902 } while( !mSortCategory[iActive].empty() );
7903 iScrollPos = 0;
7904 page_num = 0;
7905 if( iActive < 0 ) {
7906 iActive = iItemNum - 1;
7907 }
7908 } else if( action == "DOWN" ) {
7909 do {
7910 iActive++;
7911
7912 } while( !mSortCategory[iActive].empty() );
7913 iScrollPos = 0;
7914 page_num = 0;
7915 if( iActive >= iItemNum ) {
7916 iActive = mSortCategory[0].empty() ? 0 : 1;
7917 }
7918 } else if( action == "RIGHT" ) {
7919 if( !filtered_items.empty() && activeItem ) {
7920 if( ++page_num >= static_cast<int>( activeItem->vIG.size() ) ) {
7921 page_num = activeItem->vIG.size() - 1;
7922 }
7923 }
7924 } else if( action == "LEFT" ) {
7925 page_num = std::max( 0, page_num - 1 );
7926 } else if( action == "PAGE_UP" ) {
7927 iScrollPos--;
7928 } else if( action == "PAGE_DOWN" ) {
7929 iScrollPos++;
7930 } else if( action == "NEXT_TAB" || action == "PREV_TAB" ) {
7931 u.view_offset = stored_view_offset;
7933 }
7934
7935 active_pos = tripoint_zero;
7936 activeItem = nullptr;
7937
7938 if( mSortCategory[iActive].empty() ) {
7939 auto iter = filtered_items.begin();
7940 for( int iNum = 0; iter != filtered_items.end() && iNum < iActive; iNum++ ) {
7941 if( mSortCategory[iNum].empty() ) {
7942 ++iter;
7943 }
7944 }
7945 if( iter != filtered_items.end() ) {
7946 active_pos = iter->vIG[page_num].pos;
7947 activeItem = &( *iter );
7948 }
7949 }
7950
7951 if( activeItem ) {
7952 centerlistview( active_pos, width );
7953 trail_start = u.pos();
7954 trail_end = u.pos() + active_pos;
7955 // Actually accessed from the terrain overlay callback `trail_cb` in the
7956 // call to `ui_manager::redraw`.
7957 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
7958 trail_end_x = true;
7959 } else {
7960 u.view_offset = stored_view_offset;
7961 trail_start = trail_end = cata::nullopt;
7962 }
7964
7966
7967 action = ctxt.handle_input();
7968 } while( action != "QUIT" );
7969
7970 u.view_offset = stored_view_offset;
7971 return game::vmenu_ret::QUIT;
7972}
constexpr T clamp(const T &val, const T &min, const T &max)
Clamp first argument so that it is no lower than second and no higher than third.
Definition: cata_utility.h:145
std::string list_item_upvote
Definition: game.h:1079
std::string list_item_downvote
Definition: game.h:1080
std::string sFilter
Definition: game.h:1078
void reset_item_list_state(const catacurses::window &window, int height, bool bRadiusSort)
Definition: game.cpp:7415
nc_color color_in_inventory() const
Returns the color of the item depending on usefulness for the player character, e....
Definition: item.cpp:4017
static bool map_item_stack_sort(const map_item_stack &lhs, const map_item_stack &rhs)
std::vector< item_group > vIG
const item * example
string_input_popup & identifier(const std::string &value)
An identifier to be used to store / get the input history.
string_input_popup & text(const std::string &value)
Set / get the text that can be modified by the user.
void edit(std::string &value)
Edit values in place.
string_input_popup & width(int value)
Width (in console cells) of the input field itself.
string_input_popup & description(const std::string &value)
Additional help text, shown below the input box.
string_input_popup & title(const std::string &value)
The title: short string before the actual input field.
std::string list_item_priority
Definition: uistate.h:120
int list_item_sort
Definition: uistate.h:117
bool list_item_downvote_active
Definition: uistate.h:123
bool list_item_init
Definition: uistate.h:125
bool list_item_filter_active
Definition: uistate.h:122
std::string list_item_filter
Definition: uistate.h:118
bool list_item_priority_active
Definition: uistate.h:124
std::string list_item_downvote
Definition: uistate.h:119
direction direction_from(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:540
static shared_ptr_fast< game::draw_callback_t > create_trail_callback(const cata::optional< tripoint > &trail_start, const cata::optional< tripoint > &trail_end, const bool &trail_end_x)
Definition: game.cpp:3436
uistatedata uistate
Definition: game.cpp:270
static void centerlistview(const tripoint &active_item_position, int ui_width)
Definition: game.cpp:7260
std::string direction_name_short(const direction dir)
Definition: line.cpp:533
int list_filter_high_priority(std::vector< map_item_stack > &stack, const std::string &priorities)
std::vector< map_item_stack > filter_item_stacks(const std::vector< map_item_stack > &stack, const std::string &filter)
int list_filter_low_priority(std::vector< map_item_stack > &stack, const int start, const std::string &priorities)
void mvwprintw(const window &win, const point &p, const std::string &text)
void wprintw(const window &win, const std::string &text)
void calcStartPos(int &iStartPos, const int iCurrentLine, const int iContentHeight, const int iNumEntries)
Definition: output.cpp:1507
void draw_item_filter_rules(const catacurses::window &win, int starty, int height, item_filter_type type)
Write some tips (such as precede items with - to exclude them) onto the window.
Definition: output.cpp:810
void draw_scrollbar(const catacurses::window &window, const int iCurrentLine, const int iContentHeight, const int iNumLines, const point &offset, nc_color bar_color, const bool bDoNotScrollToEnd)
Draw a scrollbar (Legacy function, use class scrollbar instead!)
Definition: output.cpp:1314
std::string remove_color_tags(const std::string &s)
Removes the color tags from the input string.
Definition: output.cpp:145
void draw_custom_border(const catacurses::window &w, const catacurses::chtype ls, const catacurses::chtype rs, const catacurses::chtype ts, const catacurses::chtype bs, const catacurses::chtype tl, const catacurses::chtype tr, const catacurses::chtype bl, const catacurses::chtype br, const nc_color FG, const point &pos, int height, int width)
Definition: output.cpp:524
void trim_and_print(const catacurses::window &w, const point &begin, const int width, const nc_color &base_color, const std::string &text, const report_color_error color_error)
Prints a single line of text.
Definition: output.cpp:214
#define LINE_XOXX
Definition: output.h:47
#define LINE_XXXO
Definition: output.h:45

References _, action, add_draw_callback(), add_msg(), c_light_gray, c_light_green, c_magenta, c_red, c_white, c_yellow, calcStartPos(), centerlistview(), CHANGE_TAB, clamp(), item::color_in_inventory(), game_menus::inv::compare(), create_trail_callback(), string_input_popup::description(), direction_from(), direction_name_short(), item::display_name(), draw_custom_border(), draw_item_filter_rules(), draw_item_info(), draw_scrollbar(), string_input_popup::edit(), map_item_stack::example, FILTER, filter_item_stacks(), Character::get_path_avoid(), Character::get_pathfinding_settings(), input_context::handle_input(), item_info_data::handle_scrolling, high, HIGH_PRIORITY, string_input_popup::identifier(), item::info(), invalidate_main_ui_adaptor(), LINE_XOXX, LINE_XXXO, list_filter_high_priority(), list_filter_low_priority(), list_item_downvote, uistatedata::list_item_downvote, uistatedata::list_item_downvote_active, uistatedata::list_item_filter, uistatedata::list_item_filter_active, uistatedata::list_item_init, uistatedata::list_item_priority, uistatedata::list_item_priority_active, uistatedata::list_item_sort, list_item_upvote, LOW_PRIORITY, m, m_info, map_item_stack::map_item_stack_sort(), string_input_popup::max_length(), catacurses::mvwprintw(), mvwprintz(), catacurses::newwin(), cata::nullopt, point_south, point_zero, Character::pos(), string_input_popup::query_string(), QUIT, ui_manager::redraw(), input_context::register_action(), remove_color_tags(), reset_item_list_state(), rl_dist(), map::route(), Character::sees(), Character::set_destination(), sFilter, string_format(), TERMX, TERMY, string_input_popup::text(), string_input_popup::title(), item::tname(), to_translation(), trim_and_print(), tripoint_zero, item::type_name(), u, uistate, utf8_width(), cata::optional< T >::value(), player::view_offset, map_item_stack::vIG, catacurses::werase(), string_input_popup::width(), item_info_data::without_border, item_info_data::without_getch, catacurses::wnoutrefresh(), catacurses::wprintw(), and wprintz().

Referenced by list_items_monsters().

◆ list_items_monsters()

void game::list_items_monsters ( )
private

Definition at line 7483 of file game.cpp.

7484{
7485 std::vector<Creature *> mons = u.get_visible_creatures( current_daylight_level( calendar::turn ) );
7486 // whole reality bubble
7487 const std::vector<map_item_stack> items = find_nearby_items( 60 );
7488
7489 if( mons.empty() && items.empty() ) {
7490 add_msg( m_info, _( "You don't see any items or monsters around you!" ) );
7491 return;
7492 }
7493
7494 std::sort( mons.begin(), mons.end(), [&]( const Creature * lhs, const Creature * rhs ) {
7495 const auto att_lhs = lhs->attitude_to( u );
7496 const auto att_rhs = rhs->attitude_to( u );
7497
7498 return att_lhs < att_rhs || ( att_lhs == att_rhs
7499 && rl_dist( u.pos(), lhs->pos() ) < rl_dist( u.pos(), rhs->pos() ) );
7500 } );
7501
7502 // If the current list is empty, switch to the non-empty list
7504 if( items.empty() ) {
7505 uistate.vmenu_show_items = false;
7506 }
7507 } else if( mons.empty() ) {
7509 }
7510
7513 while( true ) {
7514 ret = uistate.vmenu_show_items ? list_items( items ) : list_monsters( mons );
7517 } else {
7518 break;
7519 }
7520 }
7521
7522 if( ret == game::vmenu_ret::FIRE ) {
7524 }
7526}
double current_daylight_level(const time_point &p)
Returns the current seasonally-adjusted maximum daylight level.
Definition: calendar.cpp:171
game::vmenu_ret list_monsters(const std::vector< Creature * > &monster_list)
Definition: game.cpp:7974
game::vmenu_ret list_items(const std::vector< map_item_stack > &item_list)
Definition: game.cpp:7528
vmenu_ret
Definition: game.h:805
std::vector< map_item_stack > find_nearby_items(int iRadius)
Definition: game.cpp:7189
void temp_exit_fullscreen()
Definition: game.cpp:536
void reenter_fullscreen()
Definition: game.cpp:546
bool vmenu_show_items
Definition: uistate.h:121

References _, add_msg(), CHANGE_TAB, current_daylight_level(), find_nearby_items(), FIRE, avatar_action::fire_wielded_weapon(), Character::get_visible_creatures(), list_items(), list_monsters(), m_info, reenter_fullscreen(), cata::hash64_detail::ret, temp_exit_fullscreen(), calendar::turn, u, uistate, and uistatedata::vmenu_show_items.

Referenced by handle_action(), and look_around().

◆ list_missions()

void game::list_missions ( )

Definition at line 22 of file mission_ui.cpp.

23{
24 catacurses::window w_missions;
25
26 enum class tab_mode : int {
27 TAB_ACTIVE = 0,
28 TAB_COMPLETED,
29 TAB_FAILED,
30 NUM_TABS,
31 FIRST_TAB = 0,
32 LAST_TAB = NUM_TABS - 1
33 };
34 tab_mode tab = tab_mode::FIRST_TAB;
35 size_t selection = 0;
36 int entries_per_page = 0;
37 input_context ctxt( "MISSIONS" );
38 ctxt.register_cardinal();
39 ctxt.register_action( "CONFIRM" );
40 ctxt.register_action( "QUIT" );
41 ctxt.register_action( "HELP_KEYBINDINGS" );
42
44 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
46
47 // content ranges from y=3 to FULL_SCREEN_HEIGHT - 2
48 entries_per_page = FULL_SCREEN_HEIGHT - 4;
49
50 ui.position_from_window( w_missions );
51 } );
52 ui.mark_resize();
53
54 std::vector<mission *> umissions;
55
56 ui.on_redraw( [&]( const ui_adaptor & ) {
57 werase( w_missions );
58 // entries_per_page * page number
59 const int top_of_page = entries_per_page * ( selection / entries_per_page );
60 const int bottom_of_page =
61 std::min( top_of_page + entries_per_page - 1, static_cast<int>( umissions.size() ) - 1 );
62
63 for( int i = 3; i < FULL_SCREEN_HEIGHT - 1; i++ ) {
64 mvwputch( w_missions, point( 30, i ), BORDER_COLOR, LINE_XOXO );
65 }
66
67 const std::vector<std::pair<tab_mode, std::string>> tabs = {
68 { tab_mode::TAB_ACTIVE, _( "ACTIVE MISSIONS" ) },
69 { tab_mode::TAB_COMPLETED, _( "COMPLETED MISSIONS" ) },
70 { tab_mode::TAB_FAILED, _( "FAILED MISSIONS" ) },
71 };
72 draw_tabs( w_missions, tabs, tab );
73 draw_border_below_tabs( w_missions );
74
75 mvwputch( w_missions, point( 30, 2 ), BORDER_COLOR,
76 tab == tab_mode::TAB_COMPLETED ? ' ' : LINE_OXXX ); // ^|^
77 mvwputch( w_missions, point( 30, FULL_SCREEN_HEIGHT - 1 ), BORDER_COLOR, LINE_XXOX ); // _|_
78
79 draw_scrollbar( w_missions, selection, entries_per_page, umissions.size(), point( 0, 3 ) );
80
81 for( int i = top_of_page; i <= bottom_of_page; i++ ) {
82 const auto miss = umissions[i];
83 const nc_color col = u.get_active_mission() == miss ? c_light_green : c_white;
84 const int y = i - top_of_page + 3;
85 trim_and_print( w_missions, point( 1, y ), 28,
86 static_cast<int>( selection ) == i ? hilite( col ) : col,
87 miss->name() );
88 }
89
90 if( selection < umissions.size() ) {
91 const auto miss = umissions[selection];
92 const nc_color col = u.get_active_mission() == miss ? c_light_green : c_white;
93 std::string for_npc;
94 if( miss->get_npc_id().is_valid() ) {
95 npc *guy = g->find_npc( miss->get_npc_id() );
96 if( guy ) {
97 for_npc = string_format( _( " for %s" ), guy->disp_name() );
98 }
99 }
100
101 int y = 3;
102 y += fold_and_print( w_missions, point( 31, y ), getmaxx( w_missions ) - 33, col,
103 miss->name() + for_npc );
104
105 auto format_tokenized_description = []( const std::string & description,
106 const std::vector<std::pair<int, itype_id>> &rewards ) {
107 std::string formatted_description = description;
108 for( const auto &reward : rewards ) {
109 std::string token = "<reward_count:" + reward.second.str() + ">";
110 formatted_description = replace_all( formatted_description, token,
111 string_format( "%d", reward.first ) );
112 }
113 return formatted_description;
114 };
115
116 y++;
117 if( !miss->get_description().empty() ) {
118 y += fold_and_print( w_missions, point( 31, y ), getmaxx( w_missions ) - 33, c_white,
119 format_tokenized_description( miss->get_description(), miss->get_likely_rewards() ) );
120 }
121 if( miss->has_deadline() ) {
122 const time_point deadline = miss->get_deadline();
123 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Deadline: %s" ), to_string( deadline ) );
124
125 if( tab != tab_mode::TAB_COMPLETED ) {
126 // There's no point in displaying this for a completed mission.
127 // @ TODO: But displaying when you completed it would be useful.
128 const time_duration remaining = deadline - calendar::turn;
129 std::string remaining_time;
130
131 if( remaining <= 0_turns ) {
132 remaining_time = _( "None!" );
133 } else if( u.has_watch() ) {
134 remaining_time = to_string( remaining );
135 } else {
136 remaining_time = to_string_approx( remaining );
137 }
138
139 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Time remaining: %s" ), remaining_time );
140 }
141 }
142 if( miss->has_target() ) {
144 // TODO: target does not contain a z-component, targets are assumed to be on z=0
145 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Target: %s You: %s" ),
146 miss->get_target().to_string(), pos.to_string() );
147 }
148 } else {
149 static const std::map< tab_mode, std::string > nope = {
150 { tab_mode::TAB_ACTIVE, translate_marker( "You have no active missions!" ) },
151 { tab_mode::TAB_COMPLETED, translate_marker( "You haven't completed any missions!" ) },
152 { tab_mode::TAB_FAILED, translate_marker( "You haven't failed any missions!" ) }
153 };
154 mvwprintz( w_missions, point( 31, 4 ), c_light_red, _( nope.at( tab ) ) );
155 }
156
157 wnoutrefresh( w_missions );
158 } );
159
160 while( true ) {
161 umissions.clear();
162 if( tab < tab_mode::FIRST_TAB || tab >= tab_mode::NUM_TABS ) {
163 debugmsg( "The sanity check failed because tab=%d", static_cast<int>( tab ) );
164 tab = tab_mode::FIRST_TAB;
165 }
166 switch( tab ) {
168 umissions = u.get_active_missions();
169 break;
170 case tab_mode::TAB_COMPLETED:
171 umissions = u.get_completed_missions();
172 break;
173 case tab_mode::TAB_FAILED:
174 umissions = u.get_failed_missions();
175 break;
176 default:
177 break;
178 }
179 if( ( !umissions.empty() && selection >= umissions.size() ) ||
180 ( umissions.empty() && selection != 0 ) ) {
181 debugmsg( "Sanity check failed: selection=%d, size=%d", static_cast<int>( selection ),
182 static_cast<int>( umissions.size() ) );
183 selection = 0;
184 }
186 const std::string action = ctxt.handle_input();
187 if( action == "RIGHT" ) {
188 tab = static_cast<tab_mode>( static_cast<int>( tab ) + 1 );
189 if( tab >= tab_mode::NUM_TABS ) {
190 tab = tab_mode::FIRST_TAB;
191 }
192 selection = 0;
193 } else if( action == "LEFT" ) {
194 tab = static_cast<tab_mode>( static_cast<int>( tab ) - 1 );
195 if( tab < tab_mode::FIRST_TAB ) {
196 tab = tab_mode::LAST_TAB;
197 }
198 selection = 0;
199 } else if( action == "DOWN" ) {
200 selection++;
201 if( selection >= umissions.size() ) {
202 selection = 0;
203 }
204 } else if( action == "UP" ) {
205 if( selection == 0 ) {
206 selection = umissions.empty() ? 0 : umissions.size() - 1;
207 } else {
208 selection--;
209 }
210 } else if( action == "CONFIRM" ) {
211 if( tab == tab_mode::TAB_ACTIVE && selection < umissions.size() ) {
212 u.set_active_mission( *umissions[selection] );
213 }
214 break;
215 } else if( action == "QUIT" ) {
216 break;
217 }
218 }
219}
std::string to_string_approx(const time_duration &dur, const bool verbose)
Returns approximate duration.
Definition: calendar.cpp:361
bool has_watch() const
Returns true if the player or their vehicle has a watch.
Definition: character.cpp:837
void set_active_mission(mission &cur_mission)
Set which mission is active.
Definition: avatar.cpp:204
mission * get_active_mission() const
Returns the mission that is currently active.
Definition: avatar.cpp:183
std::vector< mission * > get_completed_missions() const
Definition: avatar.cpp:173
std::vector< mission * > get_active_missions() const
Definition: avatar.cpp:168
std::vector< mission * > get_failed_missions() const
Definition: avatar.cpp:178
A point in the game time.
Definition: calendar.h:431
nc_color hilite(const nc_color &c)
Definition: color.cpp:509
void draw_tabs(const catacurses::window &w, const std::vector< std::string > &tab_texts, size_t current_tab)
Definition: output.cpp:1274
void draw_border_below_tabs(const catacurses::window &w, nc_color border_color)
Definition: output.cpp:587
int fold_and_print(const catacurses::window &w, const point &begin, int width, const nc_color &base_color, const std::string &text, const char split)
Fold and print text in the given window.
Definition: output.cpp:299
#define LINE_XXOX
Definition: output.h:46
std::string replace_all(std::string input, const std::string &what, const std::string &with)
Replace all occurences of 'what' within 'input' with 'with'.
#define translate_marker(x)
Marks a string literal to be extracted for translation.
Definition: translations.h:30
catacurses::window new_centered_win(int nlines, int ncols)
Definition: ui.cpp:30

References _, action, BORDER_COLOR, c_light_green, c_light_red, c_white, debugmsg, Character::disp_name(), draw_border_below_tabs(), draw_scrollbar(), draw_tabs(), fold_and_print(), FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, g, avatar::get_active_mission(), avatar::get_active_missions(), avatar::get_completed_missions(), avatar::get_failed_missions(), catacurses::getmaxx(), Character::global_omt_location(), input_context::handle_input(), Character::has_watch(), hilite(), LINE_OXXX, LINE_XOXO, LINE_XXOX, mvwprintz(), mvwputch(), new_centered_win(), ui_manager::redraw(), input_context::register_action(), input_context::register_cardinal(), replace_all(), avatar::set_active_mission(), string_format(), anonymous_namespace{bionics_ui.cpp}::TAB_ACTIVE, coords::coord_point< Point, Origin, Scale >::to_string(), to_string(), to_string_approx(), translate_marker, trim_and_print(), calendar::turn, u, catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by handle_action().

◆ list_monsters()

game::vmenu_ret game::list_monsters ( const std::vector< Creature * > &  monster_list)
private

Definition at line 7974 of file game.cpp.

7975{
7976 const int iInfoHeight = 15;
7977 const int width = 45;
7978 int offsetX = 0;
7979 int iMaxRows = 0;
7980
7981 catacurses::window w_monsters;
7982 catacurses::window w_monsters_border;
7983 catacurses::window w_monster_info;
7984 catacurses::window w_monster_info_border;
7985
7986 Creature *cCurMon = nullptr;
7987 tripoint iActivePos;
7988
7989 bool hide_ui = false;
7990
7991 ui_adaptor ui;
7992 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
7993 if( hide_ui ) {
7994 ui.position( point_zero, point_zero );
7995 } else {
7996 offsetX = TERMX - width;
7997 iMaxRows = TERMY - iInfoHeight - 1;
7998
7999 w_monsters = catacurses::newwin( iMaxRows, width - 2, point( offsetX + 1,
8000 1 ) );
8001 w_monsters_border = catacurses::newwin( iMaxRows + 1, width, point( offsetX,
8002 0 ) );
8003 w_monster_info = catacurses::newwin( iInfoHeight - 2, width - 2,
8004 point( offsetX + 1, TERMY - iInfoHeight + 1 ) );
8005 w_monster_info_border = catacurses::newwin( iInfoHeight, width, point( offsetX,
8006 TERMY - iInfoHeight ) );
8007
8008 if( cCurMon ) {
8009 centerlistview( iActivePos, width );
8010 }
8011
8012 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
8013 }
8014 } );
8015 ui.mark_resize();
8016
8017 const int max_gun_range = u.weapon.gun_range( &u );
8018
8019 const tripoint stored_view_offset = u.view_offset;
8021
8022 int iActive = 0; // monster index that we're looking at
8023
8024 std::string action;
8025 input_context ctxt( "LIST_MONSTERS" );
8026 ctxt.register_action( "UP", to_translation( "Move cursor up" ) );
8027 ctxt.register_action( "DOWN", to_translation( "Move cursor down" ) );
8028 ctxt.register_action( "NEXT_TAB" );
8029 ctxt.register_action( "PREV_TAB" );
8030 ctxt.register_action( "SAFEMODE_BLACKLIST_ADD" );
8031 ctxt.register_action( "SAFEMODE_BLACKLIST_REMOVE" );
8032 ctxt.register_action( "QUIT" );
8033 if( bVMonsterLookFire ) {
8034 ctxt.register_action( "look" );
8035 ctxt.register_action( "fire" );
8036 }
8037 ctxt.register_action( "HELP_KEYBINDINGS" );
8038
8039 // first integer is the row the attitude category string is printed in the menu
8040 std::map<int, Creature::Attitude> mSortCategory;
8041
8042 for( int i = 0, last_attitude = -1; i < static_cast<int>( monster_list.size() ); i++ ) {
8043 const auto attitude = monster_list[i]->attitude_to( u );
8044 if( attitude != last_attitude ) {
8045 mSortCategory[i + mSortCategory.size()] = attitude;
8046 last_attitude = attitude;
8047 }
8048 }
8049
8050 ui.on_redraw( [&]( const ui_adaptor & ) {
8051 if( !hide_ui ) {
8052 draw_custom_border( w_monsters_border, true, true, true, true, true, true, LINE_XOXO, LINE_XOXO );
8053 draw_custom_border( w_monster_info_border, true, true, true, true, LINE_XXXO, LINE_XOXX, true,
8054 true );
8055
8056 mvwprintz( w_monsters_border, point( 2, 0 ), c_light_green, "<Tab> " );
8057 wprintz( w_monsters_border, c_white, _( "Monsters" ) );
8058
8059 if( monster_list.empty() ) {
8060 werase( w_monsters );
8061 mvwprintz( w_monsters, point( 2, iMaxRows / 3 ), c_white,
8062 _( "You don't see any monsters around you!" ) );
8063 } else {
8064 werase( w_monsters );
8065
8066 const int iNumMonster = monster_list.size();
8067 const int iMenuSize = monster_list.size() + mSortCategory.size();
8068
8069 const int numw = iNumMonster > 999 ? 4 :
8070 iNumMonster > 99 ? 3 :
8071 iNumMonster > 9 ? 2 : 1;
8072
8073 // given the currently selected monster iActive. get the selected row
8074 int iSelPos = iActive;
8075 for( auto &ia : mSortCategory ) {
8076 int index = ia.first;
8077 if( index <= iSelPos ) {
8078 ++iSelPos;
8079 } else {
8080 break;
8081 }
8082 }
8083 int iStartPos = 0;
8084 // use selected row get the start row
8085 calcStartPos( iStartPos, iSelPos, iMaxRows - 1, iMenuSize );
8086
8087 // get first visible monster and category
8088 int iCurMon = iStartPos;
8089 auto CatSortIter = mSortCategory.cbegin();
8090 while( CatSortIter != mSortCategory.cend() && CatSortIter->first < iStartPos ) {
8091 ++CatSortIter;
8092 --iCurMon;
8093 }
8094
8095 const auto endY = std::min<int>( iMaxRows - 1, iMenuSize );
8096 for( int y = 0; y < endY; ++y ) {
8097 if( CatSortIter != mSortCategory.cend() ) {
8098 const int iCurPos = iStartPos + y;
8099 const int iCatPos = CatSortIter->first;
8100 if( iCurPos == iCatPos ) {
8101 const std::string cat_name = Creature::get_attitude_ui_data(
8102 CatSortIter->second ).first.translated();
8103 mvwprintz( w_monsters, point( 1, y ), c_magenta, cat_name );
8104 ++CatSortIter;
8105 continue;
8106 }
8107 }
8108 // select current monster
8109 const auto critter = monster_list[iCurMon];
8110 const bool selected = iCurMon == iActive;
8111 ++iCurMon;
8112 if( critter->sees( g->u ) ) {
8113 mvwprintz( w_monsters, point( 0, y ), c_yellow, "!" );
8114 }
8115 bool is_npc = false;
8116 const monster *m = dynamic_cast<monster *>( critter );
8117 const npc *p = dynamic_cast<npc *>( critter );
8118 nc_color name_color = critter->basic_symbol_color();
8119
8120 if( selected ) {
8121 name_color = hilite( name_color );
8122 }
8123
8124 if( m != nullptr ) {
8125 trim_and_print( w_monsters, point( 1, y ), width - 26, name_color, m->name() );
8126 } else {
8127 trim_and_print( w_monsters, point( 1, y ), width - 26, name_color, critter->disp_name() );
8128 is_npc = true;
8129 }
8130
8131 if( selected && !get_safemode().empty() ) {
8132 const std::string monName = is_npc ? get_safemode().npc_type_name() : m->name();
8133
8134 std::string sSafemode;
8135 if( get_safemode().has_rule( monName, Creature::A_ANY ) ) {
8136 sSafemode = _( "<R>emove from safemode Blacklist" );
8137 } else {
8138 sSafemode = _( "<A>dd to safemode Blacklist" );
8139 }
8140
8141 shortcut_print( w_monsters, point( 2, getmaxy( w_monsters ) - 1 ),
8142 c_white, c_light_green, sSafemode );
8143 }
8144
8146 std::string sText;
8147
8148 if( m != nullptr ) {
8149 m->get_HP_Bar( color, sText );
8150 } else {
8151 std::tie( sText, color ) =
8152 ::get_hp_bar( critter->get_hp(), critter->get_hp_max(), false );
8153 }
8154 mvwprintz( w_monsters, point( width - 25, y ), color, sText );
8155
8156 if( m != nullptr ) {
8157 const auto att = m->get_attitude();
8158 sText = att.first;
8159 color = att.second;
8160 } else if( p != nullptr ) {
8161 sText = npc_attitude_name( p->get_attitude() );
8162 color = p->symbol_color();
8163 }
8164 mvwprintz( w_monsters, point( width - 19, y ), color, sText );
8165
8166 const int mon_dist = rl_dist( u.pos(), critter->pos() );
8167 const int numd = mon_dist > 999 ? 4 :
8168 mon_dist > 99 ? 3 :
8169 mon_dist > 9 ? 2 : 1;
8170
8171 trim_and_print( w_monsters, point( width - ( 8 + numd ), y ), 6 + numd,
8172 selected ? c_light_green : c_light_gray,
8173 "%*d %s",
8174 numd, mon_dist,
8175 direction_name_short( direction_from( u.pos(), critter->pos() ) ) );
8176 }
8177
8178 mvwprintz( w_monsters_border, point( ( width / 2 ) - numw - 2, 0 ), c_light_green, " %*d", numw,
8179 iActive + 1 );
8180 wprintz( w_monsters_border, c_white, " / %*d ", numw, static_cast<int>( monster_list.size() ) );
8181
8182 werase( w_monster_info );
8183 if( cCurMon ) {
8184 cCurMon->print_info( w_monster_info, 1, iInfoHeight - 3, 1 );
8185 }
8186
8187 draw_custom_border( w_monster_info_border, true, true, true, true, LINE_XXXO, LINE_XOXX, true,
8188 true );
8189
8190 if( bVMonsterLookFire ) {
8191 mvwprintw( w_monster_info_border, point_east, "< " );
8192 wprintz( w_monster_info_border, c_light_green, ctxt.press_x( "look" ) );
8193 wprintz( w_monster_info_border, c_light_gray, " %s", _( "to look around" ) );
8194
8195 if( cCurMon && rl_dist( u.pos(), cCurMon->pos() ) <= max_gun_range ) {
8196 wprintw( w_monster_info_border, " " );
8197 wprintz( w_monster_info_border, c_light_green, ctxt.press_x( "fire" ) );
8198 wprintz( w_monster_info_border, c_light_gray, " %s", _( "to shoot" ) );
8199 }
8200 wprintw( w_monster_info_border, " >" );
8201 }
8202
8203 draw_scrollbar( w_monsters_border, iActive, iMaxRows, static_cast<int>( monster_list.size() ),
8204 point_south );
8205 }
8206
8207 wnoutrefresh( w_monsters_border );
8208 wnoutrefresh( w_monster_info_border );
8209 wnoutrefresh( w_monsters );
8210 wnoutrefresh( w_monster_info );
8211 }
8212 } );
8213
8214 cata::optional<tripoint> trail_start;
8215 cata::optional<tripoint> trail_end;
8216 bool trail_end_x = false;
8217 shared_ptr_fast<draw_callback_t> trail_cb = create_trail_callback( trail_start, trail_end,
8218 trail_end_x );
8219 add_draw_callback( trail_cb );
8220
8221 do {
8222 if( action == "UP" ) {
8223 iActive--;
8224 if( iActive < 0 ) {
8225 if( monster_list.empty() ) {
8226 iActive = 0;
8227 } else {
8228 iActive = static_cast<int>( monster_list.size() ) - 1;
8229 }
8230 }
8231 } else if( action == "DOWN" ) {
8232 iActive++;
8233 if( iActive >= static_cast<int>( monster_list.size() ) ) {
8234 iActive = 0;
8235 }
8236 } else if( action == "NEXT_TAB" || action == "PREV_TAB" ) {
8237 u.view_offset = stored_view_offset;
8239 } else if( action == "SAFEMODE_BLACKLIST_REMOVE" ) {
8240 const auto m = dynamic_cast<monster *>( cCurMon );
8241 const std::string monName = ( m != nullptr ) ? m->name() : "human";
8242
8243 if( get_safemode().has_rule( monName, Creature::A_ANY ) ) {
8245 }
8246 } else if( action == "SAFEMODE_BLACKLIST_ADD" ) {
8247 if( !get_safemode().empty() ) {
8248 const auto m = dynamic_cast<monster *>( cCurMon );
8249 const std::string monName = ( m != nullptr ) ? m->name() : "human";
8250
8251 get_safemode().add_rule( monName, Creature::A_ANY, get_option<int>( "SAFEMODEPROXIMITY" ),
8253 }
8254 } else if( action == "look" ) {
8255 hide_ui = true;
8256 ui.mark_resize();
8257 look_around();
8258 hide_ui = false;
8259 ui.mark_resize();
8260 } else if( action == "fire" ) {
8261 if( cCurMon != nullptr && rl_dist( u.pos(), cCurMon->pos() ) <= max_gun_range ) {
8262 u.last_target = shared_from( *cCurMon );
8264 u.view_offset = stored_view_offset;
8265 return game::vmenu_ret::FIRE;
8266 }
8267 }
8268
8269 if( iActive >= 0 && static_cast<size_t>( iActive ) < monster_list.size() ) {
8270 cCurMon = monster_list[iActive];
8271 iActivePos = cCurMon->pos() - u.pos();
8272 centerlistview( iActivePos, width );
8273 trail_start = u.pos();
8274 trail_end = cCurMon->pos();
8275 // Actually accessed from the terrain overlay callback `trail_cb` in the
8276 // call to `ui_manager::redraw`.
8277 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
8278 trail_end_x = false;
8279 } else {
8280 cCurMon = nullptr;
8281 iActivePos = tripoint_zero;
8282 u.view_offset = stored_view_offset;
8283 trail_start = trail_end = cata::nullopt;
8284 }
8286
8288
8289 action = ctxt.handle_input();
8290 } while( action != "QUIT" );
8291
8292 u.view_offset = stored_view_offset;
8293
8294 return game::vmenu_ret::QUIT;
8295}
double recoil
Definition: character.h:618
nc_color symbol_color() const override
Color's character's tile's background.
Definition: character.cpp:6101
static const std::pair< translation, nc_color > & get_attitude_ui_data(Attitude att)
Creature Attitude as String and color.
Definition: creature.cpp:1857
virtual const tripoint & pos() const =0
virtual int print_info(const catacurses::window &w, int vStart, int vLines, int column) const =0
Write information about this creature.
shared_ptr_fast< T > shared_from(const T &critter)
Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature).
Definition: game.cpp:4883
bool bVMonsterLookFire
Definition: game.h:1083
int gun_range(const player *p) const
The weapons range in map squares.
Definition: item.cpp:7201
npc_attitude get_attitude() const
Definition: npc.cpp:3136
weak_ptr_fast< Creature > last_target
Definition: player.h:690
bool has_rule(const std::string &rule_in, Creature::Attitude attitude_in)
void remove_rule(const std::string &rule_in, Creature::Attitude attitude_in)
static nc_color color(const T_t &t)
@ RULE_BLACKLISTED
Definition: enums.h:54
constexpr double MAX_RECOIL
std::string npc_attitude_name(npc_attitude att)
Definition: npc.cpp:2542
std::pair< std::string, nc_color > get_hp_bar(const int cur_hp, const int max_hp, const bool is_mon)
Definition: output.cpp:1604
size_t shortcut_print(const catacurses::window &w, const point &p, nc_color text_color, nc_color shortcut_color, const std::string &fmt)
Definition: output.cpp:1543

References _, Creature::A_ANY, action, add_draw_callback(), safemode::add_rule(), bVMonsterLookFire, c_light_gray, c_light_green, c_magenta, c_white, c_yellow, calcStartPos(), centerlistview(), CHANGE_TAB, color(), create_trail_callback(), direction_from(), direction_name_short(), draw_custom_border(), draw_scrollbar(), FIRE, g, npc::get_attitude(), Creature::get_attitude_ui_data(), get_hp_bar(), get_safemode(), catacurses::getmaxy(), item::gun_range(), input_context::handle_input(), safemode::has_rule(), hilite(), invalidate_main_ui_adaptor(), player::last_target, LINE_XOXO, LINE_XOXX, LINE_XXXO, look_around(), m, MAX_RECOIL, catacurses::mvwprintw(), mvwprintz(), map::name(), catacurses::newwin(), npc_attitude_name(), safemode::npc_type_name(), cata::nullopt, point_east, point_south, point_zero, Creature::pos(), Character::pos(), input_context::press_x(), Creature::print_info(), QUIT, Character::recoil, ui_manager::redraw(), input_context::register_action(), safemode::remove_rule(), rl_dist(), RULE_BLACKLISTED, shared_from(), shortcut_print(), Character::symbol_color(), TERMX, TERMY, to_translation(), trim_and_print(), tripoint_zero, u, player::view_offset, Character::weapon, catacurses::werase(), catacurses::wnoutrefresh(), catacurses::wprintw(), and wprintz().

Referenced by list_items_monsters().

◆ load() [1/2]

bool game::load ( const save_t name)
private

Definition at line 2844 of file game.cpp.

2845{
2848 popup.message( "%s", _( "Please wait…\nLoading the save…" ) );
2851
2852 using namespace std::placeholders;
2853
2854 const std::string worldpath = get_world_base_save_path() + "/";
2855 const std::string playerpath = worldpath + name.base_path();
2856
2857 // Now load up the master game data; factions (and more?)
2858 load_master();
2859 u = avatar();
2860 u.name = name.player_name();
2861 // This should be initialized more globally (in player/Character constructor)
2863 if( !read_from_file( playerpath + SAVE_EXTENSION, std::bind( &game::unserialize, this, _1 ) ) ) {
2864 return false;
2865 }
2866
2868
2870
2871 read_from_file_optional( worldpath + name.base_path() + SAVE_EXTENSION_LOG,
2872 std::bind( &memorial_logger::load, &memorial(), _1 ) );
2873
2874#if defined(__ANDROID__)
2875 read_from_file_optional( worldpath + name.base_path() + SAVE_EXTENSION_SHORTCUTS,
2876 std::bind( &game::load_shortcuts, this, _1 ) );
2877#endif
2878
2879 // Now that the player's worn items are updated, their sight limits need to be
2880 // recalculated. (This would be cleaner if u.worn were private.)
2882
2883 if( !gamemode ) {
2884 gamemode = std::make_unique<special_game>();
2885 }
2886
2887 safe_mode = get_option<bool>( "SAFEMODE" ) ? SAFE_MODE_ON : SAFE_MODE_OFF;
2888 mostseen = 0; // ...and mostseen is 0, we haven't seen any monsters yet.
2889
2890 init_autosave();
2891 get_auto_pickup().load_character(); // Load character auto pickup rules
2892 get_auto_notes_settings().load(); // Load character auto notes settings
2893 get_safemode().load_character(); // Load character safemode rules
2894 zone_manager::get_manager().load_zones(); // Load character world zones
2895 read_from_file_optional( get_world_base_save_path() + "/uistate.json", []( std::istream & stream ) {
2896 JsonIn jsin( stream );
2897 uistate.deserialize( jsin );
2898 } );
2899 reload_npcs();
2904 update_map( u );
2905 for( auto &e : u.inv_dump() ) {
2906 e->set_owner( g->u );
2907 }
2908 // legacy, needs to be here as we access the map.
2909 if( !u.getID().is_valid() ) {
2910 // player does not have a real id, so assign a new one,
2911 u.setID( assign_npc_id() );
2912 // The vehicle stores the IDs of the boarded players, so update it, too.
2913 if( u.in_vehicle ) {
2915 u.pos() ).part_with_feature( "BOARDABLE", true ) ) {
2916 vp->part().passenger_id = u.getID();
2917 }
2918 }
2919 }
2920
2921 // populate calendar caches now, after active world is set, but before we do
2922 // anything else, to ensure they pick up the correct value from the save's
2923 // worldoptions
2924 calendar::set_eternal_season( ::get_option<bool>( "ETERNAL_SEASON" ) );
2925 calendar::set_season_length( ::get_option<int>( "SEASON_LENGTH" ) );
2926
2927 u.reset();
2928
2929 return true;
2930}
bool read_from_file(const std::string &path, const std::function< void(std::istream &)> &reader)
Try to open and read from given file using the given callback.
bool read_from_file_optional(const std::string &path, const std::function< void(std::istream &)> &reader)
void setID(character_id i, bool force=false)
Definition: character.cpp:459
std::vector< item * > inv_dump()
Definition: character.cpp:8950
void recalc_sight_limits()
Modifies the player's sight values Must be called when any of the following change: This must be call...
Definition: character.cpp:1699
void reset() override
Handles stat and bonus reset.
Definition: character.cpp:3601
Definition: json.h:177
Definition: avatar.h:54
void load_map_memory()
Definition: avatar.cpp:132
bool is_valid() const
Definition: character_id.h:19
void validate_linked_vehicles()
validate towed vehicles so they get linked up again after a load
Definition: game.cpp:1978
void reload_npcs()
Unloads, then loads the NPCs.
Definition: game.cpp:958
void validate_camps()
validate camps to ensure they are on the overmap list
Definition: game.cpp:2036
void load_master()
Definition: game.cpp:2813
void validate_mounted_npcs()
Definition: game.cpp:1993
character_id assign_npc_id()
Definition: game.cpp:3930
void unserialize(std::istream &fin)
Definition: savegame.cpp:167
void init_autosave()
Definition: game.cpp:11783
void validate_npc_followers()
validate list of followers to account for overmap buffers
Definition: game.cpp:2012
void load(std::istream &fin)
Loads the data in a memorial file from the given ifstream.
void load_character()
Create a popup on the UI stack that gets displayed but receives no input itself.
Definition: popup.h:276
void deserialize(const JsonObject &jo)
time_point nextweather
Definition: weather.h:205
void load_zones()
Definition: clzones.cpp:1216
static const std::string SAVE_EXTENSION(".sav")
static const std::string SAVE_EXTENSION_SHORTCUTS(".shortcuts")
static const std::string SAVE_EXTENSION_LOG(".log")
void set_season_length(int dur)
Definition: calendar.cpp:478
void set_eternal_season(bool is_eternal_season)
Definition: calendar.cpp:470

References _, assign_npc_id(), uistatedata::deserialize(), g, gamemode, get_auto_notes_settings(), get_auto_pickup(), zone_manager::get_manager(), get_safemode(), get_weather, get_world_base_save_path(), Character::getID(), Character::in_vehicle, init_autosave(), Character::inv_dump(), character_id::is_valid(), auto_notes::auto_note_settings::load(), memorial_logger::load(), auto_pickup::player_settings::load_character(), safemode::load_character(), avatar::load_map_memory(), load_master(), zone_manager::load_zones(), m, memorial(), mostseen, Character::name, om_direction::name(), weather_manager::nextweather, optional_vpart_position::part_with_feature(), popup(), Character::pos(), read_from_file(), read_from_file_optional(), Character::recalc_sight_limits(), ui_manager::redraw(), refresh_display(), reload_npcs(), Character::reset(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAVE_EXTENSION(), SAVE_EXTENSION_LOG(), SAVE_EXTENSION_SHORTCUTS(), calendar::set_eternal_season(), calendar::set_season_length(), Character::setID(), calendar::start_of_cataclysm, calendar::turn, u, uistate, unserialize(), update_map(), validate_camps(), validate_linked_vehicles(), validate_mounted_npcs(), validate_npc_followers(), map::veh_at(), and Character::weapon.

◆ load() [2/2]

bool game::load ( const std::string &  world)

Attempt to load first valid save (if any) in world.

Definition at line 2820 of file game.cpp.

2821{
2822 world_generator->init();
2823 const WORLDPTR wptr = world_generator->get_world( world );
2824 if( !wptr ) {
2825 return false;
2826 }
2827 if( wptr->world_saves.empty() ) {
2828 debugmsg( "world '%s' contains no saves", world );
2829 return false;
2830 }
2831
2832 try {
2833 world_generator->set_active_world( wptr );
2834 g->setup();
2835 g->load( wptr->world_saves.front() );
2836 } catch( const std::exception &err ) {
2837 debugmsg( "cannot load world '%s': %s", world, err.what() );
2838 return false;
2839 }
2840
2841 return true;
2842}
std::vector< save_t > world_saves
Definition: worldfactory.h:61

References debugmsg, g, world_generator, and WORLD::world_saves.

Referenced by quickload().

◆ load_core_data()

void game::load_core_data ( loading_ui ui)

Loads core dynamic data.

May throw.

Definition at line 436 of file game.cpp.

437{
438 // core data can be loaded only once and must be first
439 // anyway.
441
443}
void unload_data()
Deletes and unloads all the data previously loaded with load_data_from_path.
Definition: init.cpp:523
std::string jsondir()
Definition: path_info.cpp:230

References DynamicDataLoader::get_instance(), PATH_INFO::jsondir(), load_data_from_dir(), and DynamicDataLoader::unload_data().

Referenced by check_mod_data(), dump_stats(), and setup().

◆ load_data_from_dir()

void game::load_data_from_dir ( const std::string &  path,
const std::string &  src,
loading_ui ui 
)
protected

Loads dynamic data from the given directory.

May throw.

Definition at line 445 of file game.cpp.

446{
448}
void load_data_from_path(const std::string &path, const std::string &src, loading_ui &ui)
Load all data from json files located in the path (recursive).
Definition: init.cpp:453

References DynamicDataLoader::get_instance(), and DynamicDataLoader::load_data_from_path().

Referenced by check_mod_data(), load_core_data(), and load_packs().

◆ load_map() [1/2]

void game::load_map ( const tripoint pos_sm)

Load the main map at given location, see map::load, in global, absolute submap coordinates.

Definition at line 632 of file game.cpp.

633{
634 // TODO: fix point types
635 load_map( tripoint_abs_sm( pos_sm ) );
636}
void load_map(const tripoint &pos_sm)
Load the main map at given location, see map::load, in global, absolute submap coordinates.
Definition: game.cpp:632
coords::coord_point< tripoint, coords::origin::abs, coords::sm > tripoint_abs_sm
Definition: coordinates.h:490

References load_map().

Referenced by load_map(), place_player_overmap(), start_game(), and unserialize().

◆ load_map() [2/2]

void game::load_map ( const tripoint_abs_sm pos_sm)

Definition at line 638 of file game.cpp.

639{
640 m.load( pos_sm, true );
641 grid_tracker_ptr->load( m );
642}
void load(const tripoint &w, bool update_vehicles)
Load submaps into grid.
Definition: map.cpp:6499

References grid_tracker_ptr, map::load(), and m.

◆ load_master()

void game::load_master ( )
private

Definition at line 2813 of file game.cpp.

2814{
2815 using namespace std::placeholders;
2816 const auto datafile = get_world_base_save_path() + "/" + SAVE_MASTER;
2817 read_from_file_optional( datafile, std::bind( &game::unserialize_master, this, _1 ) );
2818}
void unserialize_master(std::istream &fin)
Definition: savegame.cpp:1207
static const std::string SAVE_MASTER("master.gsav")

References get_world_base_save_path(), read_from_file_optional(), SAVE_MASTER(), and unserialize_master().

Referenced by load(), and start_game().

◆ load_npcs()

void game::load_npcs ( )

Makes any nearby NPCs on the overmap active.

Definition at line 896 of file game.cpp.

897{
898 const int radius = HALF_MAPSIZE - 1;
899 // uses submap coordinates
900 std::vector<shared_ptr_fast<npc>> just_added;
901 for( const auto &temp : overmap_buffer.get_npcs_near_player( radius ) ) {
902 const character_id &id = temp->getID();
903 const auto found = std::find_if( active_npc.begin(), active_npc.end(),
904 [id]( const shared_ptr_fast<npc> &n ) {
905 return n->getID() == id;
906 } );
907 if( found != active_npc.end() ) {
908 continue;
909 }
910 if( temp->is_active() ) {
911 continue;
912 }
913 if( temp->has_companion_mission() ) {
914 continue;
915 }
916
917 const tripoint sm_loc = temp->global_sm_location();
918 // NPCs who are out of bounds before placement would be pushed into bounds
919 // This can cause NPCs to teleport around, so we don't want that
920 if( sm_loc.x < get_levx() || sm_loc.x >= get_levx() + MAPSIZE ||
921 sm_loc.y < get_levy() || sm_loc.y >= get_levy() + MAPSIZE ||
922 ( sm_loc.z != get_levz() && !m.has_zlevels() ) ) {
923 continue;
924 }
925
926 add_msg( m_debug, "game::load_npcs: Spawning static NPC, %d:%d:%d (%d:%d:%d)",
927 get_levx(), get_levy(), get_levz(), sm_loc.x, sm_loc.y, sm_loc.z );
928 temp->place_on_map();
929 if( !m.inbounds( temp->pos() ) ) {
930 continue;
931 }
932 // In the rare case the npc was marked for death while
933 // it was on the overmap. Kill it.
934 if( temp->marked_for_death ) {
935 temp->die( nullptr );
936 } else {
937 active_npc.push_back( temp );
938 just_added.push_back( temp );
939 }
940 }
941
942 for( const auto &npc : just_added ) {
943 npc->on_load();
944 }
945
946 npcs_dirty = false;
947}
void on_load()
Retroactively update npc.
Definition: npc.cpp:2655
static constexpr int MAPSIZE

References active_npc, add_msg(), get_levx(), get_levy(), get_levz(), overmapbuffer::get_npcs_near_player(), HALF_MAPSIZE, map::has_zlevels(), map::inbounds(), m, m_debug, MAPSIZE, npcs_dirty, npc::on_load(), overmap_buffer, tripoint::x, tripoint::y, and tripoint::z.

Referenced by do_turn(), perhaps_add_random_npc(), place_player_overmap(), reload_npcs(), save_cyborg(), spawn_hallucination(), start_game(), and update_map().

◆ load_packs()

bool game::load_packs ( const std::string &  msg,
const std::vector< mod_id > &  packs,
loading_ui ui 
)

Load content packs.

Parameters
msgstring to display whilst loading prompt
packscontent packs to load in correct dependent order
uistructure for load progress display
Returns
true if all packs were found, false if any were missing

Definition at line 2968 of file game.cpp.

2969{
2970 ui.new_context( msg );
2971 std::vector<mod_id> missing;
2972 std::vector<mod_id> available;
2973
2974 for( const mod_id &e : packs ) {
2975 if( e.is_valid() ) {
2976 available.emplace_back( e );
2977 ui.add_entry( e->name() );
2978 } else {
2979 missing.push_back( e );
2980 }
2981 }
2982
2983 ui.show();
2984 for( const auto &e : available ) {
2985 const MOD_INFORMATION &mod = *e;
2986 load_data_from_dir( mod.path, mod.ident.str(), ui );
2987 ui.proceed();
2988 }
2989
2990 for( const auto &e : missing ) {
2991 debugmsg( "unknown content %s", e.c_str() );
2992 }
2993
2994 return missing.empty();
2995}

References available, string_id< T >::c_str(), debugmsg, string_id< T >::is_valid(), load_data_from_dir(), and MOD_INFORMATION::name().

Referenced by dump_stats().

◆ load_static_data()

void game::load_static_data ( )

Loads static data that does not depend on mods or similar.

Definition at line 322 of file game.cpp.

323{
324 // UI stuff, not mod-specific per definition
325 inp_mngr.init(); // Load input config JSON
326 // Init mappings for loading the json stuff
328 fullscreen = false;
329 was_fullscreen = false;
330 show_panel_adm = false;
332
333 // These functions do not load stuff from json.
334 // The content they load/initialize is hardcoded into the program.
335 // Therefore they can be loaded here.
336 // If this changes (if they load data from json), they have to
337 // be moved to game::load_mod or game::load_core_data
338
341}
bool was_fullscreen
Definition: game.h:1065
bool fullscreen
Definition: game.h:1064
void init()
Initializes the input manager, aka loads the input mapping configuration JSON.
Definition: input.cpp:111
void init()
Definition: panels.cpp:2309
void load_global()

References fullscreen, get_auto_pickup(), DynamicDataLoader::get_instance(), panel_manager::get_manager(), get_safemode(), input_manager::init(), panel_manager::init(), inp_mngr, auto_pickup::player_settings::load_global(), safemode::load_global(), show_panel_adm, and was_fullscreen.

◆ load_world_modfiles()

void game::load_world_modfiles ( loading_ui ui)

Loads core data and mods from the active world.

May throw.

Definition at line 2932 of file game.cpp.

2933{
2934 auto &mods = world_generator->active_world->active_mod_order;
2935
2936 // remove any duplicates whilst preserving order (fixes #19385)
2937 std::set<mod_id> found;
2938 mods.erase( std::remove_if( mods.begin(), mods.end(), [&found]( const mod_id & e ) {
2939 if( found.count( e ) ) {
2940 return true;
2941 } else {
2942 found.insert( e );
2943 return false;
2944 }
2945 } ), mods.end() );
2946
2947 // require at least one core mod (saves before version 6 may implicitly require dda pack)
2948 if( std::none_of( mods.begin(), mods.end(), []( const mod_id & e ) {
2949 return e->core;
2950} ) ) {
2951 mods.insert( mods.begin(), mod_id( "dda" ) );
2952 }
2953
2955 // this code does not care about mod dependencies,
2956 // it assumes that those dependencies are static and
2957 // are resolved during the creation of the world.
2958 // That means world->active_mod_order contains a list
2959 // of mods in the correct order.
2960 load_packs( _( "Loading files" ), mods, ui );
2961
2962 // Load additional mods from that world-specific folder
2963 load_data_from_dir( get_world_base_save_path() + "/mods", "custom", ui );
2964
2966}
void load_artifacts(const std::string &path)
Definition: artifact.cpp:1098
static const std::string SAVE_ARTIFACTS("artifacts.gsav")

References world_generator.

Referenced by setup().

◆ look_around() [1/2]

cata::optional< tripoint > game::look_around ( )

Definition at line 6839 of file game.cpp.

6840{
6842 look_around_result result = look_around( /*show_window=*/true, center, center, false, false,
6843 false );
6844 return result.position;
6845}

References center, look_around(), Character::pos(), u, and player::view_offset.

Referenced by handle_action(), list_monsters(), look_around(), peek(), and zones_manager().

◆ look_around() [2/2]

look_around_result game::look_around ( bool  show_window,
tripoint center,
const tripoint start_point,
bool  has_first_point,
bool  select_zone,
bool  peeking,
bool  is_moving_zone = false,
const tripoint end_point = tripoint_zero 
)
Parameters
show_windowdisplay the info window that holds the tile information in the position.
centerused to calculate the u.view_offset, could center the screen to the position it represents
start_pointthe start point of the targeting zone, also the initial local position of the cursor
has_first_pointshould be true if the first point has been selected when editing the zone
select_zonetrue if the zone is being edited
peekingdetermines if the player is peeking
is_moving_zonetrue if the zone is being moved, false by default
end_pointthe end point of the targeting zone, only used if is_moving_zone is true, default is tripoint_zero
Returns
look_around_result

Definition at line 6847 of file game.cpp.

6850{
6851 bVMonsterLookFire = false;
6852 // TODO: Make this `true`
6853 const bool allow_zlev_move = m.has_zlevels() && get_option<bool>( "FOV_3D" );
6854
6856
6857 tripoint lp = is_moving_zone ? ( start_point + end_point ) / 2 : start_point; // cursor
6858 int &lx = lp.x;
6859 int &ly = lp.y;
6860 int &lz = lp.z;
6861
6862 int soffset = get_option<int>( "FAST_SCROLL_OFFSET" );
6863 bool fast_scroll = false;
6864
6865 std::unique_ptr<ui_adaptor> ui;
6866 catacurses::window w_info;
6867 if( show_window ) {
6868 ui = std::make_unique<ui_adaptor>();
6869 ui->on_screen_resize( [&]( ui_adaptor & ui ) {
6870 int panel_width = panel_manager::get_manager().get_current_layout().begin()->get_width();
6872
6873 // If particularly small, base height on panel width irrespective of other elements.
6874 // Value here is attempting to get a square-ish result assuming 1x2 proportioned font.
6875 if( height < panel_width / 2 ) {
6876 height = panel_width / 2;
6877 }
6878
6879 int la_y = 0;
6880 int la_x = TERMX - panel_width;
6881 std::string position = get_option<std::string>( "LOOKAROUND_POSITION" );
6882 if( position == "left" ) {
6883 if( get_option<std::string>( "SIDEBAR_POSITION" ) == "right" ) {
6885 } else {
6886 la_x = panel_manager::get_manager().get_width_left() - panel_width;
6887 }
6888 }
6889 int la_h = height;
6890 int la_w = panel_width;
6891 w_info = catacurses::newwin( la_h, la_w, point( la_x, la_y ) );
6892
6893 ui.position_from_window( w_info );
6894 } );
6895 ui->mark_resize();
6896 }
6897
6898 std::string action;
6899 input_context ctxt( "LOOK" );
6900 ctxt.set_iso( true );
6901 ctxt.register_directions();
6902 ctxt.register_action( "COORDINATE" );
6903 ctxt.register_action( "LEVEL_UP" );
6904 ctxt.register_action( "LEVEL_DOWN" );
6905 ctxt.register_action( "TOGGLE_FAST_SCROLL" );
6906 ctxt.register_action( "EXTENDED_DESCRIPTION" );
6907 ctxt.register_action( "SELECT" );
6908 if( peeking ) {
6909 ctxt.register_action( "throw_blind" );
6910 }
6911 if( !select_zone ) {
6912 ctxt.register_action( "TRAVEL_TO" );
6913 ctxt.register_action( "LIST_ITEMS" );
6914 }
6915 ctxt.register_action( "MOUSE_MOVE" );
6916 ctxt.register_action( "CENTER" );
6917
6918 ctxt.register_action( "debug_scent" );
6919 ctxt.register_action( "debug_scent_type" );
6920 ctxt.register_action( "debug_temp" );
6921 ctxt.register_action( "debug_visibility" );
6922 ctxt.register_action( "debug_lighting" );
6923 ctxt.register_action( "debug_radiation" );
6924 ctxt.register_action( "debug_submap_grid" );
6925 ctxt.register_action( "debug_hour_timer" );
6926 ctxt.register_action( "CONFIRM" );
6927 ctxt.register_action( "QUIT" );
6928 ctxt.register_action( "HELP_KEYBINDINGS" );
6929 if( use_tiles ) {
6930 ctxt.register_action( "zoom_out" );
6931 ctxt.register_action( "zoom_in" );
6932 }
6933#if defined(TILES)
6934 ctxt.register_action( "toggle_pixel_minimap" );
6935#endif // TILES
6936
6937 const int old_levz = get_levz();
6938 const int min_levz = std::max( old_levz - fov_3d_z_range, -OVERMAP_DEPTH );
6939 const int max_levz = std::min( old_levz + fov_3d_z_range, OVERMAP_HEIGHT );
6940
6941 m.update_visibility_cache( old_levz );
6943
6944 bool blink = true;
6946
6947 shared_ptr_fast<draw_callback_t> ter_indicator_cb;
6948
6949 if( show_window && ui ) {
6950 ui->on_redraw( [&]( const ui_adaptor & ) {
6951 werase( w_info );
6952 draw_border( w_info );
6953
6954 center_print( w_info, 0, c_white, string_format( _( "< <color_green>Look Around</color> >" ) ) );
6955
6956 std::string extended_descr_text = string_format( _( "%s - %s" ),
6957 ctxt.get_desc( "EXTENDED_DESCRIPTION" ),
6958 ctxt.get_action_name( "EXTENDED_DESCRIPTION" ) );
6959 std::string fast_scroll_text = string_format( _( "%s - %s" ),
6960 ctxt.get_desc( "TOGGLE_FAST_SCROLL" ),
6961 ctxt.get_action_name( "TOGGLE_FAST_SCROLL" ) );
6962#if defined(TILES)
6963 std::string pixel_minimap_text = string_format( _( "%s - %s" ),
6964 ctxt.get_desc( "toggle_pixel_minimap" ),
6965 ctxt.get_action_name( "toggle_pixel_minimap" ) );
6966#endif // TILES
6967
6968 center_print( w_info, getmaxy( w_info ) - 2, c_light_gray, extended_descr_text );
6969 mvwprintz( w_info, point( 1, getmaxy( w_info ) - 1 ), fast_scroll ? c_light_green : c_green,
6970 fast_scroll_text );
6971#if defined(TILES)
6972 right_print( w_info, getmaxy( w_info ) - 1, 1, pixel_minimap_option ? c_light_green : c_green,
6973 pixel_minimap_text );
6974#endif // TILES
6975
6976 int first_line = 1;
6977 const int last_line = getmaxy( w_info ) - 3;
6978 pre_print_all_tile_info( lp, w_info, first_line, last_line, cache );
6979
6980 wnoutrefresh( w_info );
6981 } );
6982 ter_indicator_cb = make_shared_fast<draw_callback_t>( [&]() {
6983 draw_look_around_cursor( lp, cache );
6984 } );
6985 add_draw_callback( ter_indicator_cb );
6986 }
6987
6988 cata::optional<tripoint> zone_start;
6989 cata::optional<tripoint> zone_end;
6990 bool zone_blink = false;
6991 bool zone_cursor = true;
6992 shared_ptr_fast<draw_callback_t> zone_cb = create_zone_callback( zone_start, zone_end, zone_blink,
6993 zone_cursor, is_moving_zone );
6994 add_draw_callback( zone_cb );
6995
6996 is_looking = true;
6997 const tripoint prev_offset = u.view_offset;
6998#if defined(TILES)
6999 const int prev_tileset_zoom = tileset_zoom;
7000 while( is_moving_zone && square_dist( start_point, end_point ) > 256 / get_zoom() &&
7001 get_zoom() != 4 ) {
7002 zoom_out();
7003 }
7005#endif
7006 do {
7007 u.view_offset = center - u.pos();
7008 if( select_zone ) {
7009 if( has_first_point ) {
7010 zone_start = start_point;
7011 zone_end = lp;
7012 } else {
7013 zone_start = lp;
7014 zone_end = cata::nullopt;
7015 }
7016 // Actually accessed from the terrain overlay callback `zone_cb` in the
7017 // call to `ui_manager::redraw`.
7018 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
7019 zone_blink = blink;
7020 }
7021
7022 if( is_moving_zone ) {
7023 zone_start = lp - ( start_point + end_point ) / 2 + start_point;
7024 zone_end = lp - ( start_point + end_point ) / 2 + end_point;
7025 // Actually accessed from the terrain overlay callback `zone_cb` in the
7026 // call to `ui_manager::redraw`.
7027 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
7028 zone_blink = blink;
7029 }
7032 if( ( select_zone && has_first_point ) || is_moving_zone ) {
7033 ctxt.set_timeout( BLINK_SPEED );
7034 }
7035
7036 //Wait for input
7037 // only specify a timeout here if "EDGE_SCROLL" is enabled
7038 // otherwise use the previously set timeout
7039 const tripoint edge_scroll = mouse_edge_scrolling_terrain( ctxt );
7040 const int scroll_timeout = get_option<int>( "EDGE_SCROLL" );
7041 const bool edge_scrolling = edge_scroll != tripoint_zero && scroll_timeout >= 0;
7042 if( edge_scrolling ) {
7043 action = ctxt.handle_input( scroll_timeout );
7044 } else {
7045 action = ctxt.handle_input();
7046 }
7047 if( ( action == "LEVEL_UP" || action == "LEVEL_DOWN" || action == "MOUSE_MOVE" ||
7048 ctxt.get_direction( action ) ) && ( ( select_zone && has_first_point ) || is_moving_zone ) ) {
7049 blink = true; // Always draw blink symbols when moving cursor
7050 } else if( action == "TIMEOUT" ) {
7051 blink = !blink;
7052 }
7053 if( action == "LIST_ITEMS" ) {
7055 } else if( action == "TOGGLE_FAST_SCROLL" ) {
7056 fast_scroll = !fast_scroll;
7057 } else if( action == "toggle_pixel_minimap" ) {
7059
7060 if( show_window && ui ) {
7061 ui->mark_resize();
7062 }
7063 } else if( action == "LEVEL_UP" || action == "LEVEL_DOWN" ) {
7064 if( !allow_zlev_move ) {
7065 continue;
7066 }
7067
7068 const int dz = ( action == "LEVEL_UP" ? 1 : -1 );
7069 lz = clamp( lz + dz, min_levz, max_levz );
7070 center.z = clamp( center.z + dz, min_levz, max_levz );
7071
7072 add_msg( m_debug, "levx: %d, levy: %d, levz: %d", get_levx(), get_levy(), center.z );
7073 u.view_offset.z = center.z - u.posz();
7075 } else if( action == "TRAVEL_TO" ) {
7076 if( !u.sees( lp ) ) {
7077 add_msg( _( "You can't see that destination." ) );
7078 continue;
7079 }
7080
7081 auto route = m.route( u.pos(), lp, u.get_pathfinding_settings(), u.get_path_avoid() );
7082 if( route.size() > 1 ) {
7083 route.pop_back();
7084 u.set_destination( route );
7085 } else {
7086 add_msg( m_info, _( "You can't travel there." ) );
7087 continue;
7088 }
7089 } else if( action == "debug_scent" || action == "debug_scent_type" ) {
7091 display_scent();
7092 }
7093 } else if( action == "debug_temp" ) {
7096 }
7097 } else if( action == "debug_lighting" ) {
7100 }
7101 } else if( action == "debug_transparency" ) {
7104 }
7105 } else if( action == "debug_radiation" ) {
7108 }
7109 } else if( action == "debug_submap_grid" ) {
7110 g->debug_submap_grid_overlay = !g->debug_submap_grid_overlay;
7111 } else if( action == "debug_hour_timer" ) {
7113 } else if( action == "EXTENDED_DESCRIPTION" ) {
7115 } else if( action == "CENTER" ) {
7116 center = u.pos();
7117 lp = u.pos();
7118 u.view_offset.z = 0;
7119 } else if( action == "MOUSE_MOVE" || action == "TIMEOUT" ) {
7120 // This block is structured this way so that edge scroll can work
7121 // whether the mouse is moving at the edge or simply stationary
7122 // at the edge. But even if edge scroll isn't in play, there's
7123 // other things for us to do here.
7124
7125 if( edge_scrolling ) {
7126 center += action == "MOUSE_MOVE" ? edge_scroll * 2 : edge_scroll;
7127 } else if( action == "MOUSE_MOVE" ) {
7128 const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
7129 if( mouse_pos ) {
7130 lx = mouse_pos->x;
7131 ly = mouse_pos->y;
7132 }
7133 }
7134 } else if( cata::optional<tripoint> vec = ctxt.get_direction( action ) ) {
7135 if( fast_scroll ) {
7136 vec->x *= soffset;
7137 vec->y *= soffset;
7138 }
7139
7140 lx = lx + vec->x;
7141 ly = ly + vec->y;
7142 center.x = center.x + vec->x;
7143 center.y = center.y + vec->y;
7144 } else if( action == "throw_blind" ) {
7145 result.peek_action = PA_BLIND_THROW;
7146 } else if( action == "zoom_in" ) {
7147 center.x = lp.x;
7148 center.y = lp.y;
7149 zoom_in();
7151 } else if( action == "zoom_out" ) {
7152 center.x = lp.x;
7153 center.y = lp.y;
7154 zoom_out();
7156 }
7157 } while( action != "QUIT" && action != "CONFIRM" && action != "SELECT" && action != "TRAVEL_TO" &&
7158 action != "throw_blind" );
7159
7160 if( m.has_zlevels() && center.z != old_levz ) {
7161 m.invalidate_map_cache( old_levz );
7162 m.build_map_cache( old_levz );
7163 u.view_offset.z = 0;
7164 }
7165
7166 ctxt.reset_timeout();
7167 u.view_offset = prev_offset;
7168 zone_cb = nullptr;
7169 is_looking = false;
7170
7172 bVMonsterLookFire = true;
7173
7174 if( action == "CONFIRM" || action == "SELECT" ) {
7175 result.position = is_moving_zone ? zone_start : lp;
7176 }
7177
7178#if defined(TILES)
7179 if( is_moving_zone && get_zoom() != prev_tileset_zoom ) {
7180 // Reset the tileset zoom to the previous value
7181 set_zoom( prev_tileset_zoom );
7183 }
7184#endif
7185
7186 return result;
7187}
int fov_3d_z_range
3D FoV range, in Z levels, in both directions.
bool pixel_minimap_option
Whether to show the pixel minimap.
tripoint mouse_edge_scrolling_terrain(input_context &ctxt)
Used to implement mouse "edge scrolling".
Definition: game.cpp:2394
void set_zoom(int level)
Definition: game.cpp:7338
void draw_look_around_cursor(const tripoint &lp, const visibility_variables &cache)
Definition: game.cpp:5952
void extended_description(const tripoint &p)
Long description of (visible) things at tile.
void pre_print_all_tile_info(const tripoint &lp, const catacurses::window &w_info, int &line, int last_line, const visibility_variables &cache)
Definition: game.cpp:6826
int get_zoom() const
Definition: game.cpp:7350
const visibility_variables & get_visibility_variables_cache() const
Definition: map.cpp:5620
void invalidate_map_cache(const int zlev)
Definition: map.h:458
std::vector< window_panel > & get_current_layout()
Definition: panels.cpp:2277
int square_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:505
static shared_ptr_fast< game::draw_callback_t > create_zone_callback(const cata::optional< tripoint > &zone_start, const cata::optional< tripoint > &zone_end, const bool &zone_blink, const bool &zone_cursor, const bool &is_moving_zone=false)
Definition: game.cpp:3389
@ PA_BLIND_THROW
Definition: game.h:122
static constexpr int OVERMAP_HEIGHT
static constexpr int BLINK_SPEED
static constexpr int OVERMAP_DEPTH
int right_print(const catacurses::window &w, const int line, const int right_indent, const nc_color &FG, const std::string &text)
Definition: output.cpp:461

References _, action, add_draw_callback(), add_msg(), BLINK_SPEED, map::build_map_cache(), bVMonsterLookFire, c_green, c_light_gray, c_light_green, c_white, center, center_print(), clamp(), create_zone_callback(), display_lighting(), display_radiation(), display_scent(), display_temperature(), display_transparency(), draw_border(), draw_look_around_cursor(), extended_description(), fov_3d_z_range, g, input_context::get_action_name(), input_context::get_coordinates(), panel_manager::get_current_layout(), input_context::get_desc(), input_context::get_direction(), get_levx(), get_levy(), get_levz(), panel_manager::get_manager(), Character::get_path_avoid(), Character::get_pathfinding_settings(), map::get_visibility_variables_cache(), panel_manager::get_width_left(), get_zoom(), catacurses::getmaxy(), input_context::handle_input(), map::has_zlevels(), invalidate_main_ui_adaptor(), map::invalidate_map_cache(), is_looking, MAP_SHARING::isCompetitive(), MAP_SHARING::isDebugger(), list_items_monsters(), m, m_debug, m_info, mark_main_ui_adaptor_resize(), mouse_edge_scrolling_terrain(), mvwprintz(), catacurses::newwin(), cata::nullopt, OVERMAP_DEPTH, OVERMAP_HEIGHT, PA_BLIND_THROW, pixel_minimap_option, Character::pos(), Character::posz(), pre_print_all_tile_info(), ui_manager::redraw(), reenter_fullscreen(), input_context::register_action(), input_context::register_directions(), input_context::reset_timeout(), right_print(), map::route(), Character::sees(), Character::set_destination(), input_context::set_iso(), input_context::set_timeout(), set_zoom(), square_dist(), string_format(), temp_exit_fullscreen(), TERMX, TERMY, tileset_zoom, toggle_debug_hour_timer(), toggle_pixel_minimap(), tripoint_zero, u, map::update_visibility_cache(), use_tiles, player::view_offset, w_pixel_minimap, w_terrain, catacurses::werase(), catacurses::wnoutrefresh(), tripoint::x, tripoint::y, tripoint::z, zoom_in(), and zoom_out().

◆ look_debug()

cata::optional< tripoint > game::look_debug ( )

Definition at line 5945 of file game.cpp.

5946{
5947 editmap edit;
5948 return edit.edit();
5949}
cata::optional< tripoint > edit()
Definition: editmap.cpp:339

References editmap::edit().

◆ mark_main_ui_adaptor_resize()

void game::mark_main_ui_adaptor_resize ( ) const

Definition at line 3346 of file game.cpp.

3347{
3349 if( ui ) {
3350 ui->mark_resize();
3351 }
3352}

References main_ui_adaptor.

Referenced by handle_action(), look_around(), toggle_fullscreen(), and toggle_pixel_minimap().

◆ memorial()

memorial_logger & game::memorial ( )

Definition at line 3088 of file game.cpp.

3089{
3090 return *memorial_logger_ptr;
3091}

References memorial_logger_ptr.

Referenced by cleanup_at_end(), load(), save_player_data(), win(), win_screen(), and write_memorial_file().

◆ mon_info()

void game::mon_info ( const catacurses::window w,
int  hor_padding = 0 
)

Definition at line 4037 of file game.cpp.

4038{
4039 const monster_visible_info &mon_visible = u.get_mon_visible();
4040 const auto &unique_types = mon_visible.unique_types;
4041 const auto &unique_mons = mon_visible.unique_mons;
4042 const auto &dangerous = mon_visible.dangerous;
4043
4044 const int width = getmaxx( w ) - 2 * hor_padding;
4045 const int maxheight = getmaxy( w );
4046
4047 const int startrow = 0;
4048
4049 // Print the direction headings
4050 // Reminder:
4051 // 7 0 1 unique_types uses these indices;
4052 // 6 8 2 0-7 are provide by direction_from()
4053 // 5 4 3 8 is used for local monsters (for when we explain them below)
4054
4055 const std::array<std::string, 8> dir_labels = {{
4056 _( "North:" ), _( "NE:" ), _( "East:" ), _( "SE:" ),
4057 _( "South:" ), _( "SW:" ), _( "West:" ), _( "NW:" )
4058 }
4059 };
4060 std::array<int, 8> widths;
4061 for( int i = 0; i < 8; i++ ) {
4062 widths[i] = utf8_width( dir_labels[i] );
4063 }
4064 std::array<int, 8> xcoords;
4065 const std::array<int, 8> ycoords = {{ 0, 0, 1, 2, 2, 2, 1, 0 }};
4066 xcoords[0] = xcoords[4] = width / 3;
4067 xcoords[1] = xcoords[3] = xcoords[2] = ( width / 3 ) * 2;
4068 xcoords[5] = xcoords[6] = xcoords[7] = 0;
4069 //for the alignment of the 1,2,3 rows on the right edge
4070 xcoords[2] -= utf8_width( _( "East:" ) ) - utf8_width( _( "NE:" ) );
4071 for( int i = 0; i < 8; i++ ) {
4072 nc_color c = unique_types[i].empty() && unique_mons[i].empty() ? c_dark_gray
4073 : ( dangerous[i] ? c_light_red : c_light_gray );
4074 mvwprintz( w, point( xcoords[i] + hor_padding, ycoords[i] + startrow ), c, dir_labels[i] );
4075 }
4076
4077 // Print the symbols of all monsters in all directions.
4078 for( int i = 0; i < 8; i++ ) {
4079 point pr( xcoords[i] + widths[i] + 1, ycoords[i] + startrow );
4080
4081 // The list of symbols needs a space on each end.
4082 int symroom = ( width / 3 ) - widths[i] - 2;
4083 const int typeshere_npc = unique_types[i].size();
4084 const int typeshere_mon = unique_mons[i].size();
4085 const int typeshere = typeshere_mon + typeshere_npc;
4086 for( int j = 0; j < typeshere && j < symroom; j++ ) {
4087 nc_color c;
4088 std::string sym;
4089 if( symroom < typeshere && j == symroom - 1 ) {
4090 // We've run out of room!
4091 c = c_white;
4092 sym = "+";
4093 } else if( j < typeshere_npc ) {
4094 switch( unique_types[i][j]->get_attitude() ) {
4095 case NPCATT_KILL:
4096 c = c_red;
4097 break;
4098 case NPCATT_FOLLOW:
4099 c = c_light_green;
4100 break;
4101 default:
4102 c = c_pink;
4103 break;
4104 }
4105 sym = "@";
4106 } else {
4107 const mtype &mt = *unique_mons[i][j - typeshere_npc];
4108 c = mt.color;
4109 sym = mt.sym;
4110 }
4111 mvwprintz( w, pr, c, sym );
4112
4113 pr.x++;
4114 }
4115 }
4116
4117 // Now we print their full names!
4118
4119 std::set<const mtype *> listed_mons;
4120
4121 // Start printing monster names on row 4. Rows 0-2 are for labels, and row 3
4122 // is blank.
4123 point pr( hor_padding, 4 + startrow );
4124
4125 // Print monster names, starting with those at location 8 (nearby).
4126 for( int j = 8; j >= 0 && pr.y < maxheight; j-- ) {
4127 // Separate names by some number of spaces (more for local monsters).
4128 int namesep = ( j == 8 ? 2 : 1 );
4129 for( const mtype *type : unique_mons[j] ) {
4130 if( pr.y >= maxheight ) {
4131 // no space to print to anyway
4132 break;
4133 }
4134 if( listed_mons.count( type ) > 0 ) {
4135 // this type is already printed.
4136 continue;
4137 }
4138 listed_mons.insert( type );
4139
4140 const mtype &mt = *type;
4141 const std::string name = mt.nname();
4142
4143 // Move to the next row if necessary. (The +2 is for the "Z ").
4144 if( pr.x + 2 + utf8_width( name ) >= width ) {
4145 pr.y++;
4146 pr.x = hor_padding;
4147 }
4148
4149 if( pr.y < maxheight ) { // Don't print if we've overflowed
4150 mvwprintz( w, pr, mt.color, mt.sym );
4151 pr.x += 2; // symbol and space
4152 nc_color danger = c_dark_gray;
4153 if( mt.difficulty >= 30 ) {
4154 danger = c_red;
4155 } else if( mt.difficulty >= 16 ) {
4156 danger = c_light_red;
4157 } else if( mt.difficulty >= 8 ) {
4158 danger = c_white;
4159 } else if( mt.agro > 0 ) {
4160 danger = c_light_gray;
4161 }
4162 mvwprintz( w, pr, danger, name );
4163 pr.x += utf8_width( name ) + namesep;
4164 }
4165 }
4166 }
4167}
@ NPCATT_KILL
Definition: npc.h:91
@ NPCATT_FOLLOW
Definition: npc.h:84
std::vector< const mtype * > unique_mons[9]
Definition: avatar.h:47
bool dangerous[8]
Definition: avatar.h:50
std::vector< npc * > unique_types[9]
Definition: avatar.h:46
Definition: mtype.h:208
std::string sym
UTF-8 encoded symbol, should be exactly one cell wide.
Definition: mtype.h:253
nc_color color
Definition: mtype.h:258
int difficulty
Definition: mtype.h:264
int agro
e.g.
Definition: mtype.h:269

References _, mtype::agro, c, c_dark_gray, c_light_gray, c_light_green, c_light_red, c_pink, c_red, c_white, mtype::color, monster_visible_info::dangerous, mtype::difficulty, avatar::get_mon_visible(), catacurses::getmaxx(), catacurses::getmaxy(), mvwprintz(), om_direction::name(), mtype::nname(), NPCATT_FOLLOW, NPCATT_KILL, mtype::sym, type, u, monster_visible_info::unique_mons, monster_visible_info::unique_types, utf8_width(), point::x, and point::y.

◆ mon_info_update()

void game::mon_info_update ( )

Definition at line 4169 of file game.cpp.

4170{
4171 int newseen = 0;
4172 const int safe_proxy_dist = get_option<int>( "SAFEMODEPROXIMITY" );
4173 const int iProxyDist = ( safe_proxy_dist <= 0 ) ? MAX_VIEW_DISTANCE :
4174 safe_proxy_dist;
4175
4176 monster_visible_info &mon_visible = u.get_mon_visible();
4177 auto &new_seen_mon = mon_visible.new_seen_mon;
4178 auto &unique_types = mon_visible.unique_types;
4179 auto &unique_mons = mon_visible.unique_mons;
4180 auto &dangerous = mon_visible.dangerous;
4181
4182 // 7 0 1 unique_types uses these indices;
4183 // 6 8 2 0-7 are provide by direction_from()
4184 // 5 4 3 8 is used for local monsters (for when we explain them below)
4185 for( auto &t : unique_types ) {
4186 t.clear();
4187 }
4188 for( auto &m : unique_mons ) {
4189 m.clear();
4190 }
4191 std::fill( dangerous, dangerous + 8, false );
4192
4193 const tripoint view = u.pos() + u.view_offset;
4194 new_seen_mon.clear();
4195
4196 // TODO: no reason to have it static here
4197 static time_point previous_turn = calendar::start_of_cataclysm;
4198 const time_duration sm_ignored_time = time_duration::from_turns(
4199 get_option<int>( "SAFEMODEIGNORETURNS" ) );
4200
4202 monster *m = dynamic_cast<monster *>( c );
4203 npc *p = dynamic_cast<npc *>( c );
4204 const direction dir_to_mon = direction_from( view.xy(), point( c->posx(), c->posy() ) );
4205 const int mx = POSX + ( c->posx() - view.x );
4206 const int my = POSY + ( c->posy() - view.y );
4207 int index = 8;
4208 if( !is_valid_in_w_terrain( point( mx, my ) ) ) {
4209 // for compatibility with old code, see diagram below, it explains the values for index,
4210 // also might need revisiting one z-levels are in.
4211 switch( dir_to_mon ) {
4215 index = 7;
4216 break;
4218 case direction::NORTH:
4220 index = 0;
4221 break;
4225 index = 1;
4226 break;
4228 case direction::WEST:
4230 index = 6;
4231 break;
4233 case direction::CENTER:
4235 index = 8;
4236 break;
4238 case direction::EAST:
4240 index = 2;
4241 break;
4245 index = 5;
4246 break;
4248 case direction::SOUTH:
4250 index = 4;
4251 break;
4255 index = 3;
4256 break;
4257 }
4258 }
4259
4260 rule_state safemode_state = RULE_NONE;
4261 const bool safemode_empty = get_safemode().empty();
4262
4263 if( m != nullptr ) {
4264 //Safemode monster check
4265 monster &critter = *m;
4266
4267 const monster_attitude matt = critter.attitude( &u );
4268 const int mon_dist = rl_dist( u.pos(), critter.pos() );
4269 safemode_state = get_safemode().check_monster( critter.name(), critter.attitude_to( u ), mon_dist );
4270
4271 if( ( !safemode_empty && safemode_state == RULE_BLACKLISTED ) || ( safemode_empty &&
4272 ( MATT_ATTACK == matt || MATT_FOLLOW == matt ) ) ) {
4273 if( index < 8 && critter.sees( g->u ) ) {
4274 dangerous[index] = true;
4275 }
4276
4277 if( !safemode_empty || mon_dist <= iProxyDist ) {
4278 bool passmon = false;
4279 if( critter.ignoring > 0 ) {
4280 if( safe_mode != SAFE_MODE_ON ) {
4281 critter.ignoring = 0;
4282 } else if( ( sm_ignored_time == 0_seconds || ( critter.lastseen_turn &&
4283 *critter.lastseen_turn > calendar::turn - sm_ignored_time ) ) &&
4284 ( mon_dist > critter.ignoring / 2 || mon_dist < 6 ) ) {
4285 passmon = true;
4286 }
4287 critter.lastseen_turn = calendar::turn;
4288 }
4289
4290 if( !passmon ) {
4291 newseen++;
4292 new_seen_mon.push_back( shared_from( critter ) );
4293 }
4294 }
4295 }
4296
4297 std::vector<const mtype *> &vec = unique_mons[index];
4298 if( std::find( vec.begin(), vec.end(), critter.type ) == vec.end() ) {
4299 vec.push_back( critter.type );
4300 }
4301 } else if( p != nullptr ) {
4302 //Safe mode NPC check
4303
4304 const int npc_dist = rl_dist( u.pos(), p->pos() );
4305 safemode_state = get_safemode().check_monster( get_safemode().npc_type_name(), p->attitude_to( u ),
4306 npc_dist );
4307
4308 if( ( !safemode_empty && safemode_state == RULE_BLACKLISTED ) || ( safemode_empty &&
4309 p->get_attitude() == NPCATT_KILL ) ) {
4310 if( !safemode_empty || npc_dist <= iProxyDist ) {
4311 newseen++;
4312 }
4313 }
4314 unique_types[index].push_back( p );
4315 }
4316 }
4317
4318 if( newseen > mostseen ) {
4319 if( newseen - mostseen == 1 ) {
4320 if( !new_seen_mon.empty() ) {
4321 monster &critter = *new_seen_mon.back();
4323 string_format( _( "%s spotted!" ), critter.name() ) );
4324 if( u.has_trait( trait_id( "M_DEFENDER" ) ) && critter.type->in_species( PLANT ) ) {
4325 add_msg( m_warning, _( "We have detected a %s - an enemy of the Mycus!" ), critter.name() );
4327 u.add_effect( effect_adrenaline_mycus, 30_minutes );
4328 } else if( u.get_effect_int( effect_adrenaline_mycus ) == 1 ) {
4329 // Triffids present. We ain't got TIME to adrenaline comedown!
4330 u.add_effect( effect_adrenaline_mycus, 15_minutes );
4331 u.mod_pain( 3 ); // Does take it out of you, though
4332 add_msg( m_info, _( "Our fibers strain with renewed wrath!" ) );
4333 }
4334 }
4335 } else {
4336 //Hostile NPC
4338 _( "Hostile survivor spotted!" ) );
4339 }
4340 } else {
4342 }
4344 if( safe_mode == SAFE_MODE_ON ) {
4346 }
4347 } else if( calendar::turn > previous_turn && get_option<bool>( "AUTOSAFEMODE" ) &&
4348 newseen == 0 ) { // Auto-safe mode, but only if it's a new turn
4349 turnssincelastmon += to_turns<int>( calendar::turn - previous_turn );
4350 if( turnssincelastmon >= get_option<int>( "AUTOSAFEMODETURNS" ) && safe_mode == SAFE_MODE_OFF ) {
4352 add_msg( m_info, _( "Safe mode ON!" ) );
4353 }
4354 }
4355
4356 if( newseen == 0 && safe_mode == SAFE_MODE_STOP ) {
4358 }
4359
4360 previous_turn = calendar::turn;
4361 mostseen = newseen;
4362}
int get_effect_int(const efftype_id &eff_id, body_part bp=num_bp) const
Returns the intensity of the matching effect.
Definition: creature.cpp:1247
virtual bool sees(const Creature &critter) const
The functions check whether this creature can see the target.
Definition: creature.cpp:202
bool cancel_activity_or_ignore_query(distraction_type type, const std::string &text)
Asks if the player wants to cancel their activity and if so cancels it.
Definition: game.cpp:1790
monster_attitude attitude(const Character *u=nullptr) const
Definition: monster.cpp:1066
cata::optional< time_point > lastseen_turn
Definition: monster.h:506
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
Definition: npc.cpp:2074
rule_state check_monster(const std::string &creature_name_in, Creature::Attitude attitude_in, int proximity_in) const
bool empty() const
rule_state
Definition: enums.h:51
@ RULE_NONE
Definition: enums.h:52
bool is_valid_in_w_terrain(const point &p)
Definition: game.cpp:272
static const species_id PLANT("PLANT")
static const efftype_id effect_adrenaline_mycus("adrenaline_mycus")
static constexpr int MAPSIZE_X
monster_attitude
Definition: monster.h:54
@ MATT_FOLLOW
Definition: monster.h:60
@ MATT_ATTACK
Definition: monster.h:61
FMT_NOINLINE OutputIt fill(OutputIt it, size_t n, const fill_t< Char > &fill)
bool in_species(const species_id &spec) const
Definition: mtype.cpp:122

References _, ABOVECENTER, ABOVEEAST, ABOVENORTH, ABOVENORTHEAST, ABOVENORTHWEST, ABOVESOUTH, ABOVESOUTHEAST, ABOVESOUTHWEST, ABOVEWEST, Creature::add_effect(), add_msg(), monster::attitude(), monster::attitude_to(), npc::attitude_to(), BELOWCENTER, BELOWEAST, BELOWNORTH, BELOWNORTHEAST, BELOWNORTHWEST, BELOWSOUTH, BELOWSOUTHEAST, BELOWSOUTHWEST, BELOWWEST, c, cancel_activity_or_ignore_query(), CENTER, safemode::check_monster(), monster_visible_info::dangerous, direction_from(), EAST, effect_adrenaline_mycus, safemode::empty(), detail::fill(), detail::find(), time_duration::from_turns(), g, npc::get_attitude(), Creature::get_effect_int(), avatar::get_mon_visible(), get_safemode(), Character::get_visible_creatures(), Creature::has_effect(), Character::has_trait(), hostile_spotted_far, monster::ignoring, mtype::in_species(), is_valid_in_w_terrain(), monster::lastseen_turn, m, m_info, m_warning, MAPSIZE_X, MATT_ATTACK, MATT_FOLLOW, MAX_VIEW_DISTANCE, player::mod_pain(), mostseen, monster::name(), monster_visible_info::new_seen_mon, NORTH, NORTHEAST, NORTHWEST, NPCATT_KILL, PLANT, Character::pos(), monster::pos(), POSX, POSY, rl_dist(), RULE_BLACKLISTED, RULE_NONE, safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAFE_MODE_STOP, Creature::sees(), set_safe_mode(), shared_from(), SOUTH, SOUTHEAST, SOUTHWEST, calendar::start_of_cataclysm, string_format(), calendar::turn, turnssincelastmon, monster::type, u, monster_visible_info::unique_mons, monster_visible_info::unique_types, player::view_offset, WEST, tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by do_turn().

◆ monmove()

void game::monmove ( )
private

Definition at line 4399 of file game.cpp.

4400{
4401 cleanup_dead();
4402
4403 for( monster &critter : all_monsters() ) {
4404 // Critters in impassable tiles get pushed away, unless it's not impassable for them
4405 if( !critter.is_dead() && m.impassable( critter.pos() ) && !critter.can_move_to( critter.pos() ) ) {
4406 std::string msg = string_format( "%s can't move to its location! %s %s", critter.name(),
4407 critter.pos().to_string(), m.tername( critter.pos() ) );
4408 dbg( DL::Error ) << msg;
4409 add_msg( m_debug, msg );
4410 bool okay = false;
4411 for( const tripoint &dest : m.points_in_radius( critter.pos(), 3 ) ) {
4412 if( critter.can_move_to( dest ) && is_empty( dest ) ) {
4413 critter.setpos( dest );
4414 okay = true;
4415 break;
4416 }
4417 }
4418 if( !okay ) {
4419 // die of "natural" cause (overpopulation is natural)
4420 critter.die( nullptr );
4421 }
4422 }
4423
4424 if( !critter.is_dead() ) {
4425 critter.process_items();
4426 }
4427
4428 if( !critter.is_dead() ) {
4429 critter.process_turn();
4430 }
4431
4432 m.creature_in_field( critter );
4433 if( calendar::once_every( 1_days ) ) {
4434 if( critter.has_flag( MF_MILKABLE ) ) {
4435 critter.refill_udders();
4436 }
4437 critter.try_reproduce();
4438 }
4439 while( critter.moves > 0 && !critter.is_dead() && !critter.has_effect( effect_ridden ) ) {
4440 critter.made_footstep = false;
4441 // Controlled critters don't make their own plans
4442 if( !critter.has_effect( effect_ai_controlled ) ) {
4443 // Formulate a path to follow
4444 critter.plan();
4445 }
4446 critter.move(); // Move one square, possibly hit u
4447 critter.process_triggers();
4448 m.creature_in_field( critter );
4449 }
4450
4451 if( !critter.is_dead() &&
4452 u.has_active_bionic( bionic_id( "bio_alarm" ) ) &&
4453 u.get_power_level() >= 25_kJ &&
4454 rl_dist( u.pos(), critter.pos() ) <= 5 &&
4455 !critter.is_hallucination() ) {
4456 u.mod_power_level( -25_kJ );
4457 add_msg( m_warning, _( "Your motion alarm goes off!" ) );
4459 _( "Your motion alarm goes off!" ) );
4460 if( u.has_effect( efftype_id( "sleep" ) ) ) {
4461 u.wake_up();
4462 }
4463 }
4464 }
4465
4466 cleanup_dead();
4467
4468 // The remaining monsters are all alive, but may be outside of the reality bubble.
4469 // If so, despawn them. This is not the same as dying, they will be stored for later and the
4470 // monster::die function is not called.
4471 for( monster &critter : all_monsters() ) {
4472 if( critter.posx() < 0 - ( MAPSIZE_X ) / 6 ||
4473 critter.posy() < 0 - ( MAPSIZE_Y ) / 6 ||
4474 critter.posx() > ( MAPSIZE_X * 7 ) / 6 ||
4475 critter.posy() > ( MAPSIZE_Y * 7 ) / 6 ) {
4476 despawn_monster( critter );
4477 }
4478 }
4479
4480 // Now, do active NPCs.
4481 for( npc &guy : g->all_npcs() ) {
4482 int turns = 0;
4483 if( guy.is_mounted() ) {
4484 guy.check_mount_is_spooked();
4485 }
4486 m.creature_in_field( guy );
4487 if( !guy.has_effect( effect_npc_suspend ) ) {
4488 guy.process_turn();
4489 }
4490 while( !guy.is_dead() && guy.moves > 0 && turns < 10 &&
4491 ( !guy.in_sleep_state() || guy.activity.id() == ACT_OPERATION )
4492 ) {
4493 int moves = guy.moves;
4494 guy.move();
4495 if( moves == guy.moves ) {
4496 // Count every time we exit npc::move() without spending any moves.
4497 turns++;
4498 }
4499
4500 // Turn on debug mode when in infinite loop
4501 // It has to be done before the last turn, otherwise
4502 // there will be no meaningful debug output.
4503 if( turns == 9 ) {
4504 debugmsg( "NPC %s entered infinite loop. Turning on debug mode",
4505 guy.name );
4506 debug_mode = true;
4507 }
4508 }
4509
4510 // If we spun too long trying to decide what to do (without spending moves),
4511 // Invoke cognitive suspension to prevent an infinite loop.
4512 if( turns == 10 ) {
4513 add_msg( _( "%s faints!" ), guy.name );
4514 guy.reboot();
4515 }
4516
4517 if( !guy.is_dead() ) {
4518 guy.npc_update_body();
4519 }
4520 }
4521 cleanup_dead();
4522}
void mod_power_level(const units::energy &npower)
Definition: character.cpp:1983
units::energy get_power_level() const
Definition: character.cpp:1963
void wake_up()
Definition: avatar.cpp:947
static const activity_id ACT_OPERATION("ACT_OPERATION")
static const efftype_id effect_npc_suspend("npc_suspend")
static const efftype_id effect_ai_controlled("ai_controlled")
static constexpr int MAPSIZE_Y
@ MF_MILKABLE
Definition: mtype.h:167

References _, ACT_OPERATION, add_msg(), all_monsters(), cancel_activity_or_ignore_query(), cleanup_dead(), map::creature_in_field(), dbg, debug_mode, debugmsg, despawn_monster(), effect_ai_controlled, effect_npc_suspend, effect_ridden, Error, g, Character::get_power_level(), Character::has_active_bionic(), Creature::has_effect(), map::impassable(), is_empty(), m, m_debug, m_warning, MAPSIZE_X, MAPSIZE_Y, MF_MILKABLE, Character::mod_power_level(), motion_alarm, calendar::once_every(), map::points_in_radius(), Character::pos(), rl_dist(), string_format(), map::tername(), u, and avatar::wake_up().

Referenced by do_turn().

◆ mouse_edge_scrolling()

std::pair< tripoint, tripoint > game::mouse_edge_scrolling ( input_context ctxt,
int  speed,
const tripoint last,
bool  iso 
)
private

Definition at line 2341 of file game.cpp.

2343{
2344 const int rate = get_option<int>( "EDGE_SCROLL" );
2345 auto ret = std::make_pair( tripoint_zero, last );
2346 if( rate == -1 ) {
2347 // Fast return when the option is disabled.
2348 return ret;
2349 }
2350 // Ensure the parameters are used even if the #if below is false
2351 ( void ) ctxt;
2352 ( void ) speed;
2353 ( void ) iso;
2354#if (defined TILES || defined _WIN32 || defined WINDOWS)
2355 auto now = std::chrono::steady_clock::now();
2356 if( now < last_mouse_edge_scroll + std::chrono::milliseconds( rate ) ) {
2357 return ret;
2358 } else {
2360 }
2361 const input_event event = ctxt.get_raw_input();
2362 if( event.type == CATA_INPUT_MOUSE ) {
2363 const point threshold( projected_window_width() / 100, projected_window_height() / 100 );
2364 if( event.mouse_pos.x <= threshold.x ) {
2365 ret.first.x -= speed;
2366 if( iso ) {
2367 ret.first.y -= speed;
2368 }
2369 } else if( event.mouse_pos.x >= projected_window_width() - threshold.x ) {
2370 ret.first.x += speed;
2371 if( iso ) {
2372 ret.first.y += speed;
2373 }
2374 }
2375 if( event.mouse_pos.y <= threshold.y ) {
2376 ret.first.y -= speed;
2377 if( iso ) {
2378 ret.first.x += speed;
2379 }
2380 } else if( event.mouse_pos.y >= projected_window_height() - threshold.y ) {
2381 ret.first.y += speed;
2382 if( iso ) {
2383 ret.first.x -= speed;
2384 }
2385 }
2386 ret.second = ret.first;
2387 } else if( event.type == CATA_INPUT_TIMEOUT ) {
2388 ret.first = ret.second;
2389 }
2390#endif
2391 return ret;
2392}
@ CATA_INPUT_TIMEOUT
Definition: input.h:81
@ CATA_INPUT_MOUSE
Definition: input.h:84

References CATA_INPUT_MOUSE, CATA_INPUT_TIMEOUT, input_context::get_raw_input(), iso, last, last_mouse_edge_scroll, cata::hash64_detail::ret, tripoint_zero, point::x, and point::y.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ mouse_edge_scrolling_overmap()

tripoint game::mouse_edge_scrolling_overmap ( input_context ctxt)

This variant is suitable for the overmap.

Definition at line 2403 of file game.cpp.

2404{
2405 // overmap has no iso mode
2409 return ret.first;
2410}
std::pair< tripoint, tripoint > mouse_edge_scrolling(input_context &ctxt, int speed, const tripoint &last, bool iso)
Definition: game.cpp:2341
tripoint last_mouse_edge_scroll_vector_terrain
Definition: game.h:1117
tripoint last_mouse_edge_scroll_vector_overmap
Definition: game.h:1118

References last_mouse_edge_scroll_vector_overmap, last_mouse_edge_scroll_vector_terrain, mouse_edge_scrolling(), cata::hash64_detail::ret, and tripoint_zero.

◆ mouse_edge_scrolling_terrain()

tripoint game::mouse_edge_scrolling_terrain ( input_context ctxt)

Used to implement mouse "edge scrolling".

Returns a tripoint which is a vector of the resulting "move", i.e. (0, 0, 0) if the mouse is not at the edge of the screen, otherwise some (x, y, 0) depending on which edges are hit. This variant adjust scrolling speed according to zoom level, making it suitable when viewing the "terrain".

Definition at line 2394 of file game.cpp.

References DEFAULT_TILESET_ZOOM, last_mouse_edge_scroll_vector_overmap, last_mouse_edge_scroll_vector_terrain, mouse_edge_scrolling(), cata::hash64_detail::ret, tile_iso, tileset_zoom, and tripoint_zero.

Referenced by look_around().

◆ move_save_to_graveyard()

void game::move_save_to_graveyard ( const std::string &  dirname)
private

Definition at line 2775 of file game.cpp.

2776{
2777 const std::string save_dir = get_world_base_save_path();
2778 const std::string graveyard_dir = PATH_INFO::graveyarddir() + "/";
2779 const std::string graveyard_save_dir = graveyard_dir + dirname + "/";
2780 const std::string prefix = base64_encode( u.name ) + ".";
2781
2782 if( !assure_dir_exist( graveyard_dir ) ) {
2783 debugmsg( "could not create graveyard path '%s'", graveyard_dir );
2784 }
2785
2786 if( !assure_dir_exist( graveyard_save_dir ) ) {
2787 debugmsg( "could not create graveyard path '%s'", graveyard_save_dir );
2788 }
2789
2790 const auto save_files = get_files_from_path( prefix, save_dir );
2791 if( save_files.empty() ) {
2792 debugmsg( "could not find save files in '%s'", save_dir );
2793 }
2794
2795 for( const auto &src_path : save_files ) {
2796 const std::string dst_path = graveyard_save_dir +
2797 src_path.substr( src_path.rfind( '/' ), std::string::npos );
2798
2799 if( rename_file( src_path, dst_path ) ) {
2800 continue;
2801 }
2802
2803 debugmsg( "could not rename file '%s' to '%s'", src_path, dst_path );
2804
2805 if( remove_file( src_path ) ) {
2806 continue;
2807 }
2808
2809 debugmsg( "could not remove file '%s'", src_path );
2810 }
2811}
@ prefix
Definition: enums.h:79
bool remove_file(const std::string &path)
Remove a file.
Definition: filesystem.cpp:89
bool assure_dir_exist(const std::string &path)
Create directory if it does not exist.
Definition: filesystem.cpp:48
bool rename_file(const std::string &old_path, const std::string &new_path)
Rename a file, overwriting the target.
Definition: filesystem.cpp:105
std::vector< std::string > get_files_from_path(const std::string &pattern, const std::string &root_path, const bool recursive_search, const bool match_extension)
Returns a vector of files or directories matching pattern at root_path.
Definition: filesystem.cpp:362
std::string graveyarddir()
Definition: path_info.cpp:202

References assure_dir_exist(), base64_encode(), debugmsg, get_files_from_path(), get_world_base_save_path(), PATH_INFO::graveyarddir(), Character::name, prefix, remove_file(), rename_file(), and u.

Referenced by cleanup_at_end().

◆ moving_vehicle_dismount()

void game::moving_vehicle_dismount ( const tripoint dest_loc)

Handles players exiting from moving vehicles.

Definition at line 5413 of file game.cpp.

5414{
5415 const optional_vpart_position vp = m.veh_at( u.pos() );
5416 if( !vp ) {
5417 debugmsg( "Tried to exit non-existent vehicle." );
5418 return;
5419 }
5420 vehicle *const veh = &vp->vehicle();
5421 if( u.pos() == dest_loc ) {
5422 debugmsg( "Need somewhere to dismount towards." );
5423 return;
5424 }
5425 tileray ray( dest_loc.xy() + point( -u.posx(), -u.posy() ) );
5426 // TODO:: make dir() const correct!
5427 const units::angle d = ray.dir();
5428 add_msg( _( "You dive from the %s." ), veh->name );
5429 m.unboard_vehicle( u.pos() );
5430 u.moves -= 200;
5431 // Dive three tiles in the direction of tox and toy
5432 fling_creature( &u, d, 30, true );
5433 // Hit the ground according to vehicle speed
5434 if( !m.has_flag( "SWIMMABLE", u.pos() ) ) {
5435 if( veh->velocity > 0 ) {
5436 fling_creature( &u, veh->face.dir(), veh->velocity / static_cast<float>( 100 ) );
5437 } else {
5438 fling_creature( &u, veh->face.dir() + 180_degrees,
5439 -( veh->velocity ) / static_cast<float>( 100 ) );
5440 }
5441 }
5442}
void fling_creature(Creature *c, const units::angle &dir, float flvel, bool controlled=false, bool suppress_map_update=false)
Flings the input creature in the given direction.
Definition: game.cpp:10303

References _, add_msg(), debugmsg, tileray::dir(), vehicle::face, fling_creature(), map::has_flag(), m, Creature::moves, vehicle::name, Character::pos(), Character::posx(), Character::posy(), u, map::unboard_vehicle(), map::veh_at(), vehicle::velocity, and tripoint::xy().

◆ natural_light_level()

float game::natural_light_level ( int  zlev) const

Definition at line 3856 of file game.cpp.

3857{
3858 // ignore while underground or above limits
3859 if( zlev > OVERMAP_HEIGHT || zlev < 0 ) {
3860 return LIGHT_AMBIENT_MINIMAL;
3861 }
3862
3863 if( latest_lightlevels[zlev] > -std::numeric_limits<float>::max() ) {
3864 // Already found the light level for now?
3865 return latest_lightlevels[zlev];
3866 }
3867
3868 float ret = LIGHT_AMBIENT_MINIMAL;
3869
3870 // Sunlight/moonlight related stuff
3872 if( !weather.lightning_active ) {
3874 } else {
3875 // Recent lightning strike has lit the area
3877 }
3878
3880
3881 // Artifact light level changes here. Even though some of these only have an effect
3882 // aboveground it is cheaper performance wise to simply iterate through the entire
3883 // list once instead of twice.
3884 float mod_ret = -1;
3885 // Each artifact change does std::max(mod_ret, new val) since a brighter end value
3886 // will trump a lower one.
3887 if( const timed_event *e = timed_events.get( TIMED_EVENT_DIM ) ) {
3888 // TIMED_EVENT_DIM slowly dims the natural sky level, then relights it.
3889 const time_duration left = e->when - calendar::turn;
3890 // TIMED_EVENT_DIM has an occurrence date of turn + 50, so the first 25 dim it,
3891 if( left > 25_turns ) {
3892 mod_ret = std::max( static_cast<double>( mod_ret ), ( ret * ( left - 25_turns ) ) / 25_turns );
3893 // and the last 25 scale back towards normal.
3894 } else {
3895 mod_ret = std::max( static_cast<double>( mod_ret ), ( ret * ( 25_turns - left ) ) / 25_turns );
3896 }
3897 }
3899 // TIMED_EVENT_ARTIFACT_LIGHT causes everywhere to become as bright as day.
3900 mod_ret = std::max<float>( ret, default_daylight_level() );
3901 }
3902 // If we had a changed light level due to an artifact event then it overwrites
3903 // the natural light level.
3904 if( mod_ret > -1 ) {
3905 ret = mod_ret;
3906 }
3907
3908 // Cap everything to our minimum light level
3909 ret = std::max<float>( LIGHT_AMBIENT_MINIMAL, ret );
3910
3911 latest_lightlevels[zlev] = ret;
3912
3913 return ret;
3914}
double default_daylight_level()
How much light is provided in full daylight.
Definition: calendar.cpp:62
float sunlight(const time_point &p, const bool vision)
Returns the current sunlight or moonlight level through the preceding functions.
Definition: calendar.cpp:199
std::array< float, OVERMAP_LAYERS > latest_lightlevels
Definition: game.h:1090
bool queued(timed_event_type type) const
timed_event * get(timed_event_type type)
weather_type_id weather_id
Definition: weather.h:193
static constexpr float LIGHT_AMBIENT_MINIMAL
Definition: lightmap.h:12
@ TIMED_EVENT_DIM
Definition: timed_event.h:22
@ TIMED_EVENT_ARTIFACT_LIGHT
Definition: timed_event.h:23

References default_daylight_level(), timed_event_manager::get(), get_weather, latest_lightlevels, left, LIGHT_AMBIENT_MINIMAL, weather_type::light_modifier, OVERMAP_HEIGHT, timed_event_manager::queued(), cata::hash64_detail::ret, sunlight(), TIMED_EVENT_ARTIFACT_LIGHT, TIMED_EVENT_DIM, timed_events, calendar::turn, and weather_manager::weather_id.

Referenced by light_level().

◆ npc_menu()

bool game::npc_menu ( npc who)

Returns true if the menu handled stuff and player shouldn't do anything else.

Perception slightly increases precision when examining NPCs' wounds Firstaid increases precision when examining NPCs' wounds

Definition at line 5544 of file game.cpp.

5545{
5546 enum choices : int {
5547 talk = 0,
5548 swap_pos,
5549 push,
5550 examine_wounds,
5551 use_item,
5552 sort_armor,
5553 attack,
5554 disarm,
5555 steal
5556 };
5557
5558 const bool obeys = debug_mode || ( who.is_player_ally() && !who.in_sleep_state() );
5559
5560 uilist amenu;
5561
5562 amenu.text = string_format( _( "What to do with %s?" ), who.disp_name() );
5563 amenu.addentry( talk, true, 't', _( "Talk" ) );
5564 amenu.addentry( swap_pos, obeys && !who.is_mounted() &&
5565 !u.is_mounted(), 's', _( "Swap positions" ) );
5566 amenu.addentry( push, obeys && !who.is_mounted(), 'p', _( "Push away" ) );
5567 amenu.addentry( examine_wounds, true, 'w', _( "Examine wounds" ) );
5568 amenu.addentry( use_item, true, 'i', _( "Use item on" ) );
5569 amenu.addentry( sort_armor, true, 'r', _( "Sort armor" ) );
5570 amenu.addentry( attack, true, 'a', _( "Attack" ) );
5571 if( !who.is_player_ally() ) {
5572 amenu.addentry( disarm, who.is_armed(), 'd', _( "Disarm" ) );
5573 amenu.addentry( steal, !who.is_enemy(), 'S', _( "Steal" ) );
5574 }
5575
5576 amenu.query();
5577
5578 const int choice = amenu.ret;
5579 if( choice == talk ) {
5580 who.talk_to_u();
5581 } else if( choice == swap_pos ) {
5582 if( !prompt_dangerous_tile( who.pos() ) ) {
5583 return true;
5584 }
5585 // TODO: Make NPCs protest when displaced onto dangerous crap
5586 add_msg( _( "You swap places with %s." ), who.name );
5587 swap_critters( u, who );
5588 // TODO: Make that depend on stuff
5589 u.mod_moves( -200 );
5590 } else if( choice == push ) {
5591 // TODO: Make NPCs protest when displaced onto dangerous crap
5592 tripoint oldpos = who.pos();
5593 who.move_away_from( u.pos(), true );
5594 u.mod_moves( -20 );
5595 if( oldpos != who.pos() ) {
5596 add_msg( _( "%s moves out of the way." ), who.name );
5597 } else {
5598 add_msg( m_warning, _( "%s has nowhere to go!" ), who.name );
5599 }
5600 } else if( choice == examine_wounds ) {
5601 ///\EFFECT_PER slightly increases precision when examining NPCs' wounds
5602
5603 ///\EFFECT_FIRSTAID increases precision when examining NPCs' wounds
5604 const bool precise = u.get_skill_level( skill_firstaid ) * 4 + u.per_cur >= 20;
5605 who.body_window( _( "Limbs of: " ) + who.disp_name(), true, precise, 0, 0, 0, 0.0f, 0.0f, 0.0f,
5606 0.0f, 0.0f );
5607 } else if( choice == use_item ) {
5608 static const std::string heal_string( "heal" );
5609 const auto will_accept = []( const item & it ) {
5610 const auto use_fun = it.get_use( heal_string );
5611 if( use_fun == nullptr ) {
5612 return false;
5613 }
5614
5615 const auto *actor = dynamic_cast<const heal_actor *>( use_fun->get_actor_ptr() );
5616
5617 return actor != nullptr &&
5618 actor->limb_power >= 0 &&
5619 actor->head_power >= 0 &&
5620 actor->torso_power >= 0;
5621 };
5622 item_location loc = game_menus::inv::titled_filter_menu( will_accept, u, _( "Use which item?" ) );
5623
5624 if( !loc ) {
5625 add_msg( _( "Never mind" ) );
5626 return false;
5627 }
5628 item &used = *loc;
5629 bool did_use = u.invoke_item( &used, heal_string, who.pos() );
5630 if( did_use ) {
5631 // Note: exiting a body part selection menu counts as use here
5632 u.mod_moves( -300 );
5633 }
5634 } else if( choice == sort_armor ) {
5635 who.sort_armor();
5636 u.mod_moves( -100 );
5637 } else if( choice == attack ) {
5638 if( who.is_enemy() || query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5639 u.melee_attack( who, true );
5640 who.on_attacked( u );
5641 }
5642 } else if( choice == disarm ) {
5643 if( who.is_enemy() || query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5644 u.disarm( who );
5645 }
5646 } else if( choice == steal && query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5647 u.steal( who );
5648 }
5649
5650 return true;
5651}
hp_part body_window(const std::string &menu_header, bool show_all, bool precise, int normal_bonus, int head_bonus, int torso_bonus, float bleed, float bite, float infect, float bandage_power, float disinfectant_power) const
Displays menu with body part hp, optionally with hp estimation after healing.
Definition: character.cpp:5840
bool in_sleep_state() const override
Definition: character.cpp:9311
void melee_attack(Creature &t, bool allow_special, const matec_id &force_technique, bool allow_unarmed=true)
Sets up a melee attack and handles melee attack function calls.
Definition: melee.cpp:390
int per_cur
Definition: character.h:307
void steal(npc &target)
Try to steal an item from the NPC's inventory.
Definition: melee.cpp:2340
bool prompt_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:9243
bool swap_critters(Creature &, Creature &)
Swaps positions of two creatures.
Definition: game.cpp:5070
float limb_power
How much hp to restore when healing limbs?
Definition: iuse_actor.h:1011
void talk_to_u(bool radio_contact=false)
Definition: npctalk.cpp:730
void on_attacked(const Creature &attacker)
Definition: npc.cpp:1446
void move_away_from(const tripoint &p, bool no_bash_atk=false, std::set< tripoint > *nomove=nullptr)
Definition: npcmove.cpp:2516
void disarm(npc &target)
Try to disarm the NPC.
Definition: melee.cpp:2264
static const skill_id skill_firstaid("firstaid")
static void swap_pos(Creature &caster, const tripoint &target)
item_location steal(avatar &you, player &victim)
Menu for stealing stuff.
item_location titled_filter_menu(item_filter filter, avatar &you, const std::string &title, const std::string &none_message="")
void push(monster &z)
Definition: monexamine.cpp:552

References _, add_msg(), uilist::addentry(), Character::body_window(), debug_mode, player::disarm(), Character::disp_name(), Character::get_skill_level(), Character::in_sleep_state(), avatar::invoke_item(), Character::is_armed(), npc::is_enemy(), Character::is_mounted(), npc::is_player_ally(), heal_actor::limb_power, m_warning, Character::melee_attack(), Creature::mod_moves(), npc::move_away_from(), Character::name, npc::on_attacked(), Character::per_cur, Character::pos(), prompt_dangerous_tile(), monexamine::push(), uilist::query(), query_yn(), uilist::ret, skill_firstaid, player::sort_armor(), game_menus::inv::steal(), avatar::steal(), string_format(), swap_critters(), swap_pos(), npc::talk_to_u(), uilist::text, game_menus::inv::titled_filter_menu(), u, and avatar_action::use_item().

Referenced by examine().

◆ num_creatures()

size_t game::num_creatures ( ) const

Returns the approximate number of creatures in the reality bubble.

Because of performance restrictions it may return a slightly incorrect values (as it includes dead, but not yet cleaned up creatures).

Definition at line 5015 of file game.cpp.

5016{
5017 return critter_tracker->size() + active_npc.size() + 1; // 1 == g->u
5018}

References active_npc, and critter_tracker.

Referenced by display_visibility(), and fungal_effects::fungalize().

◆ on_move_effects()

void game::on_move_effects ( )

Definition at line 10261 of file game.cpp.

10262{
10263 // TODO: Move this to a character method
10264 if( !u.is_mounted() ) {
10265 const item muscle( "muscle" );
10266 for( const bionic_id &bid : u.get_bionic_fueled_with( muscle ) ) {
10267 if( u.has_active_bionic( bid ) ) {// active power gen
10268 u.mod_power_level( units::from_kilojoule( muscle.fuel_energy() ) * bid->fuel_efficiency );
10269 } else if( u.has_bionic( bid ) ) {// passive power gen
10270 u.mod_power_level( units::from_kilojoule( muscle.fuel_energy() ) * bid->passive_fuel_efficiency );
10271 }
10272 }
10273
10274 if( u.has_active_bionic( bionic_id( "bio_jointservo" ) ) ) {
10275 if( u.movement_mode_is( CMM_RUN ) ) {
10276 u.mod_power_level( -55_J );
10277 } else {
10278 u.mod_power_level( -35_J );
10279 }
10280 }
10281 }
10282
10283 if( u.movement_mode_is( CMM_RUN ) ) {
10284 if( !u.can_run() ) {
10286 }
10287 }
10288
10289 // apply martial art move bonuses
10290 u.martial_arts_data->ma_onmove_effects( u );
10291
10293}
@ CMM_RUN
Definition: character.h:98
bool can_run()
source of truth of whether a Character can run
Definition: character.cpp:1325
bool movement_mode_is(character_movemode mode) const
Check against the character's current movement mode.
Definition: character.cpp:1615
std::vector< bionic_id > get_bionic_fueled_with(const item &it) const
Return bionic_id of bionics able to use it as fuel.
Definition: character.cpp:1924
bool has_bionic(const bionic_id &b) const
Returns true if the player has the entered bionic id.
Definition: character.cpp:1873
void do_ambient()
Definition: sounds.cpp:1616
constexpr quantity< value_type, energy_in_joule_tag > from_kilojoule(const value_type v)
Definition: units_energy.h:32

References Character::can_run(), CMM_RUN, sfx::do_ambient(), units::from_kilojoule(), item::fuel_energy(), Character::get_bionic_fueled_with(), Character::has_active_bionic(), Character::has_bionic(), Character::is_mounted(), Character::martial_arts_data, Character::mod_power_level(), Character::movement_mode_is(), avatar::toggle_run_mode(), and u.

Referenced by phasing_move(), and walk_move().

◆ on_options_changed()

void game::on_options_changed ( )

Should be invoked whenever options change.

Definition at line 10295 of file game.cpp.

10296{
10297#if defined(TILES)
10298 tilecontext->on_options_changed();
10299#endif
10300 grid_tracker_ptr->on_options_changed();
10301}

References grid_tracker_ptr.

◆ open_consume_item_menu()

void game::open_consume_item_menu ( )
private

Definition at line 1486 of file handle_action.cpp.

1487{
1488 uilist as_m;
1489
1490 as_m.text = _( "What do you want to consume?" );
1491
1492 as_m.entries.emplace_back( 0, true, 'f', _( "Food" ) );
1493 as_m.entries.emplace_back( 1, true, 'd', _( "Drink" ) );
1494 as_m.entries.emplace_back( 2, true, 'm', _( "Medication" ) );
1495 as_m.query();
1496
1497 switch( as_m.ret ) {
1498 case 0:
1500 break;
1501 case 1:
1503 break;
1504 case 2:
1506 break;
1507 default:
1508 break;
1509 }
1510}
item_location consume_drink(player &p)
Consuming a drink item via a custom menu.
item_location consume_meds(player &p)
Consuming a medication item via a custom menu.
item_location consume_food(player &p)
Consuming a food item via a custom menu.

References _, game_menus::inv::consume_drink(), game_menus::inv::consume_food(), game_menus::inv::consume_meds(), avatar_action::eat(), uilist::entries, uilist::query(), uilist::ret, uilist::text, and u.

Referenced by handle_action().

◆ open_gate()

void game::open_gate ( const tripoint p)

Definition at line 5408 of file game.cpp.

5409{
5410 gates::open_gate( p, u );
5411}
void open_gate(const tripoint &pos, player &p)
opens the gate via player's activity
Definition: gates.cpp:236

References gates::open_gate(), and u.

◆ overmap_npc_move()

void game::overmap_npc_move ( )
private

Definition at line 4524 of file game.cpp.

4525{
4526 std::vector<npc *> travelling_npcs;
4527 static constexpr int move_search_radius = 600;
4528 for( auto &elem : overmap_buffer.get_npcs_near_player( move_search_radius ) ) {
4529 if( !elem ) {
4530 continue;
4531 }
4532 npc *npc_to_add = elem.get();
4533 if( ( !npc_to_add->is_active() || rl_dist( u.pos(), npc_to_add->pos() ) > SEEX * 2 ) &&
4534 npc_to_add->mission == NPC_MISSION_TRAVELLING ) {
4535 travelling_npcs.push_back( npc_to_add );
4536 }
4537 }
4538 for( auto &elem : travelling_npcs ) {
4539 if( elem->has_omt_destination() ) {
4540 if( !elem->omt_path.empty() && rl_dist( elem->omt_path.back(), elem->global_omt_location() ) > 2 ) {
4541 //recalculate path, we got distracted doing something else probably
4542 elem->omt_path.clear();
4543 }
4544 if( elem->omt_path.empty() ) {
4545 const tripoint_abs_omt &from = elem->global_omt_location();
4546 const tripoint_abs_omt &to = elem->goal;
4547 elem->omt_path = overmap_buffer.get_travel_path( elem->global_omt_location(), elem->goal,
4549 if( elem->omt_path.empty() ) {
4550 add_msg( m_debug, "%s couldn't find overmap path from %s to %s",
4551 elem->get_name(), from.to_string(), to.to_string() );
4552 elem->goal = npc::no_goal_point;
4553 elem->mission = NPC_MISSION_NULL;
4554 }
4555 } else {
4556 if( elem->omt_path.back() == elem->global_omt_location() ) {
4557 elem->omt_path.pop_back();
4558 }
4559 // TODO: fix point types
4560 elem->travel_overmap(
4561 project_to<coords::sm>( elem->omt_path.back() ).raw() );
4562 }
4563 reload_npcs();
4564 }
4565 }
4566 return;
4567}
std::vector< tripoint_abs_omt > omt_path
Definition: character.h:1030
static constexpr tripoint_abs_omt no_goal_point
Definition: npc.h:1338
bool is_active() const
Definition: npc.cpp:2192
std::vector< tripoint_abs_omt > get_travel_path(const tripoint_abs_omt &src, const tripoint_abs_omt &dest, overmap_path_params params)
@ NPC_MISSION_NULL
Definition: npc.h:179
@ NPC_MISSION_TRAVELLING
Definition: npc.h:191
static overmap_path_params for_npc()

References add_msg(), overmap_path_params::for_npc(), overmapbuffer::get_npcs_near_player(), overmapbuffer::get_travel_path(), npc::is_active(), m_debug, npc::mission, npc::no_goal_point, NPC_MISSION_NULL, NPC_MISSION_TRAVELLING, Character::omt_path, overmap_buffer, Character::pos(), reload_npcs(), rl_dist(), SEEX, coords::coord_point< Point, Origin, Scale >::to_string(), and u.

Referenced by do_turn().

◆ peek() [1/2]

void game::peek ( )

Definition at line 5903 of file game.cpp.

5904{
5905 const cata::optional<tripoint> p = choose_direction( _( "Peek where?" ), true );
5906 if( !p ) {
5907 return;
5908 }
5909
5910 if( p->z != 0 ) {
5911 const tripoint old_pos = u.pos();
5912 vertical_move( p->z, false, true );
5913
5914 if( old_pos != u.pos() ) {
5915 look_around();
5916 vertical_move( p->z * -1, false, true );
5917 }
5918 return;
5919 }
5920
5921 if( m.impassable( u.pos() + *p ) ) {
5922 return;
5923 }
5924
5925 peek( u.pos() + *p );
5926}
cata::optional< tripoint > choose_direction(const std::string &message, const bool allow_vertical)
Request player input of a direction, possibly including vertical component.
Definition: action.cpp:971

References _, choose_direction(), map::impassable(), look_around(), m, peek(), Character::pos(), u, and vertical_move().

Referenced by handle_action(), and peek().

◆ peek() [2/2]

void game::peek ( const tripoint p)

Definition at line 5928 of file game.cpp.

5929{
5930 u.moves -= 200;
5931 tripoint prev = u.pos();
5932 u.setpos( p );
5933 tripoint center = p;
5934 const look_around_result result = look_around( /*show_window=*/true, center, center, false, false,
5935 true );
5936 u.setpos( prev );
5937
5938 if( result.peek_action && *result.peek_action == PA_BLIND_THROW ) {
5939 item_location loc;
5940 avatar_action::plthrow( u, loc, p );
5941 }
5943}

References center, map::invalidate_map_cache(), look_around(), m, Creature::moves, PA_BLIND_THROW, avatar_action::plthrow(), Character::pos(), Character::setpos(), u, and tripoint::z.

◆ perhaps_add_random_npc()

void game::perhaps_add_random_npc ( )
private

Definition at line 11569 of file game.cpp.

11570{
11571 if( !calendar::once_every( 1_hours ) ) {
11572 return;
11573 }
11574 // Create a new NPC?
11575 // Only allow NPCs on 0 z-level, otherwise they can bug out due to lack of spots
11576 if( !get_option<bool>( "RANDOM_NPC" ) || ( !m.has_zlevels() && get_levz() != 0 ) ) {
11577 return;
11578 }
11579
11580 float density = get_option<float>( "NPC_DENSITY" );
11581 static constexpr int density_search_radius = 60;
11582 const float npc_num = overmap_buffer.get_npcs_near_player( density_search_radius ).size();
11583 if( npc_num > 0.0 ) {
11584 // 100%, 80%, 64%, 52%, 41%, 33%...
11585 density *= std::pow( 0.8f, npc_num );
11586 }
11587
11588 if( !x_in_y( density, 100 ) ) {
11589 return;
11590 }
11591 bool spawn_allowed = false;
11593 int counter = 0;
11594 while( !spawn_allowed ) {
11595 if( counter >= 10 ) {
11596 return;
11597 }
11598 static constexpr int radius_spawn_range = 120;
11599 const tripoint_abs_omt u_omt = u.global_omt_location();
11600 spawn_point = u_omt + point( rng( -radius_spawn_range, radius_spawn_range ),
11601 rng( -radius_spawn_range, radius_spawn_range ) );
11602 spawn_point.z() = 0;
11603 const oter_id oter = overmap_buffer.ter( spawn_point );
11604 // shouldn't spawn on lakes or rivers.
11605 if( !is_river_or_lake( oter ) ) {
11606 spawn_allowed = true;
11607 }
11608 counter += 1;
11609 }
11610 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
11611 tmp->normalize();
11612 tmp->randomize();
11613 std::string new_fac_id = "solo_";
11614 new_fac_id += tmp->name;
11615 // create a new "lone wolf" faction for this one NPC
11616 faction *new_solo_fac = faction_manager_ptr->add_new_faction( tmp->name, faction_id( new_fac_id ),
11617 faction_id( "no_faction" ) );
11618 tmp->set_fac( new_solo_fac ? new_solo_fac->id : faction_id( "no_faction" ) );
11619 // adds the npc to the correct overmap.
11620 // Only spawn random NPCs on z-level 0
11621 // TODO: fix point types
11622 tripoint submap_spawn = omt_to_sm_copy( spawn_point.raw() );
11623 tmp->spawn_at_sm( tripoint( submap_spawn.xy(), 0 ) );
11625 tmp->form_opinion( u );
11626 tmp->mission = NPC_MISSION_NULL;
11627 tmp->long_term_goal_action();
11628 tmp->add_new_mission( mission::reserve_random( ORIGIN_ANY_NPC, tmp->global_omt_location(),
11629 tmp->getID() ) );
11630 // This will make the new NPC active- if its nearby to the player
11631 load_npcs();
11632}
faction_id id
Definition: faction.h:82
point omt_to_sm_copy(const point &p)
@ ORIGIN_ANY_NPC
Definition: mission.h:46
bool is_river_or_lake(const oter_id &ter)
Definition: overmap.cpp:539

References faction_manager_ptr, get_levz(), overmapbuffer::get_npcs_near_player(), Character::global_omt_location(), map::has_zlevels(), faction_template::id, overmapbuffer::insert_npc(), is_river_or_lake(), load_npcs(), m, NPC_MISSION_NULL, omt_to_sm_copy(), calendar::once_every(), ORIGIN_ANY_NPC, overmap_buffer, mission::reserve_random(), rng(), overmapbuffer::ter(), u, x_in_y(), and tripoint::xy().

Referenced by do_turn().

◆ phasing_move()

bool game::phasing_move ( const tripoint dest,
bool  via_ramp = false 
)

Definition at line 9993 of file game.cpp.

9994{
9995 if( dest_loc.z != u.posz() && !via_ramp ) {
9996 // No vertical phasing yet
9997 return false;
9998 }
9999
10000 //probability travel through walls but not water
10001 tripoint dest = dest_loc;
10002 // tile is impassable
10003 int tunneldist = 0;
10004 const point d( sgn( dest.x - u.posx() ), sgn( dest.y - u.posy() ) );
10005 while( m.impassable( dest ) ||
10006 ( critter_at( dest ) != nullptr && tunneldist > 0 ) ) {
10007 //add 1 to tunnel distance for each impassable tile in the line
10008 tunneldist += 1;
10009 //Being dimensionally anchored prevents quantum shenanigans.
10010 if( u.worn_with_flag( "DIMENSIONAL_ANCHOR" ) || u.has_effect_with_flag( "DIMENSIONAL_ANCHOR" ) ) {
10012 _( "You try to quantum tunnel through the barrier, but something holds you back!" ) );
10013 return false;
10014 }
10015
10016 if( tunneldist > 24 ) {
10017 add_msg( m_info, _( "It's too dangerous to tunnel that far!" ) );
10018 return false;
10019 }
10020
10021 dest.x += d.x;
10022 dest.y += d.y;
10023 }
10024
10025 if( tunneldist != 0 ) {
10026 if( ( tunneldist - 1 ) * 100_kJ
10027 > //The first 100 was already taken up by the bionic's activation cost.
10028 u.get_power_level() ) { //oops, not enough energy! Tunneling costs 100 bionic power per impassable tile
10029 if( tunneldist * 100_kJ >
10031 add_msg( _( "You try to quantum tunnel through the barrier but bounce off! You don't have enough bionic power capacity to travel that far." ) );
10032 } else {
10033 add_msg( _( "You try to quantum tunnel through the barrier but are reflected! You need %i bionic power to travel that thickness of material." ),
10034 ( 100 * tunneldist ) );
10035 }
10036 return false;
10037 }
10038
10039 if( u.in_vehicle ) {
10040 m.unboard_vehicle( u.pos() );
10041 }
10042
10043 add_msg( _( "You quantum tunnel through the %d-tile wide barrier!" ), tunneldist );
10044 //tunneling costs 100 bionic power per impassable tile, but the first 100 was already drained by activation.
10045 u.mod_power_level( -( ( tunneldist - 1 ) * 100_kJ ) );
10046 //tunneling costs 100 moves baseline, 50 per extra tile up to a cap of 500 moves
10047 u.moves -= ( 50 + ( tunneldist * 50 ) );
10048 u.setpos( dest );
10049
10050 if( m.veh_at( u.pos() ).part_with_feature( "BOARDABLE", true ) ) {
10051 m.board_vehicle( u.pos(), &u );
10052 }
10053
10054 u.grab( OBJECT_NONE );
10056 m.creature_on_trap( u );
10057 return true;
10058 }
10059
10060 return false;
10061}
bool worn_with_flag(const std::string &flag, const bodypart_id &bp=bodypart_str_id::NULL_ID()) const
Returns true if the player is wearing an item with the given flag.
Definition: character.cpp:3249
units::energy get_max_power_level() const
Definition: character.cpp:1968
bool has_effect_with_flag(const std::string &flag, body_part bp=num_bp) const
Check if creature has any effect with the given flag.
Definition: creature.cpp:1198
void on_move_effects()
Definition: game.cpp:10261
void board_vehicle(const tripoint &p, player *pl)
Definition: map.cpp:1043
constexpr int sgn(const T x)
Definition: enums.h:8

References _, add_msg(), player::add_msg_if_player(), map::board_vehicle(), map::creature_on_trap(), critter_at(), Character::get_max_power_level(), Character::get_power_level(), avatar::grab(), Creature::has_effect_with_flag(), map::impassable(), Character::in_vehicle, m, m_info, Character::mod_power_level(), Creature::moves, OBJECT_NONE, on_move_effects(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), Character::setpos(), sgn(), u, map::unboard_vehicle(), map::veh_at(), Character::worn_with_flag(), point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

◆ pickup() [1/2]

void game::pickup ( )
private

Definition at line 5874 of file game.cpp.

5875{
5876 const cata::optional<tripoint> examp_ = choose_adjacent_highlight( _( "Pickup where?" ),
5877 _( "There is nothing to pick up nearby." ),
5878 ACTION_PICKUP, false );
5879 if( !examp_ ) {
5880 return;
5881 }
5882 pickup( *examp_ );
5883}

References _, ACTION_PICKUP, choose_adjacent_highlight(), and pickup().

Referenced by handle_action(), and pickup().

◆ pickup() [2/2]

void game::pickup ( const tripoint p)
private

Definition at line 5885 of file game.cpp.

5886{
5887 // Highlight target
5888 shared_ptr_fast<game::draw_callback_t> hilite_cb = make_shared_fast<game::draw_callback_t>( [&]() {
5889 m.drawsq( w_terrain, p, drawsq_params().highlight( true ) );
5890 } );
5891 add_draw_callback( hilite_cb );
5892
5893 pickup::pick_up( p, 0 );
5894}

References add_draw_callback(), map::drawsq(), m, pickup::pick_up(), and w_terrain.

◆ pickup_feet()

void game::pickup_feet ( )
private

Definition at line 5896 of file game.cpp.

5897{
5898 pickup::pick_up( u.pos(), 1 );
5899}

References pickup::pick_up(), Character::pos(), and u.

Referenced by handle_action().

◆ place_critter_around() [1/2]

monster * game::place_critter_around ( const mtype_id id,
const tripoint center,
int  radius 
)

Definition at line 4963 of file game.cpp.

4964{
4965 // TODO: change this into an assert, it must never happen.
4966 if( id.is_null() ) {
4967 return nullptr;
4968 }
4969 return place_critter_around( make_shared_fast<monster>( id ), center, radius );
4970}
monster * place_critter_around(const mtype_id &id, const tripoint &center, int radius)
Definition: game.cpp:4963

References center, and place_critter_around().

Referenced by place_critter_around(), place_critter_at(), replace_stair_monsters(), and start_game().

◆ place_critter_around() [2/2]

monster * game::place_critter_around ( const shared_ptr_fast< monster > &  mon,
const tripoint center,
int  radius,
bool  forced = false 
)

Definition at line 4972 of file game.cpp.

4976{
4978 if( forced || can_place_monster( *mon, center ) ) {
4979 where = center;
4980 }
4981
4982 // This loop ensures the monster is placed as close to the center as possible,
4983 // but all places that equally far from the center have the same probability.
4984 for( int r = 1; r <= radius && !where; ++r ) {
4986 }
4987
4988 if( !where ) {
4989 return nullptr;
4990 }
4991 mon->spawn( *where );
4992 return critter_tracker->add( mon ) ? mon.get() : nullptr;
4993}
static cata::optional< tripoint > choose_where_to_place_monster(const monster &mon, const tripoint_range< tripoint > &range)
Definition: game.cpp:4945
static bool can_place_monster(const monster &mon, const tripoint &p)
Definition: game.cpp:4929

References can_place_monster(), center, choose_where_to_place_monster(), critter_tracker, m, and map::points_in_radius().

◆ place_critter_at() [1/2]

monster * game::place_critter_at ( const mtype_id id,
const tripoint p 
)

Adds critters to the reality bubble, creating them if necessary.

Functions taking a id parameter will construct a monster based on that id, (with default properties). Functions taking a mon parameter will use the supplied monster instance instead (which must not be null). Note: the monster will not be upgraded by these functions, it is placed as is.

place_critter_at will place the creature exactly at the given point.

place_critter_around will place the creature around the center p within the given radius (radius 0 means only the center point is used). The chosen point will be as close to the center as possible.

place_critter_within will place the creature at a random point within that given range. (All points within have equal probability.)

Returns
All functions return null if the creature could not be placed (usually because the target is not suitable for it: may be a solid wall, or air, or already occupied by some creature). If the creature has been placed, it returns a pointer to it (which is the same as the one contained in mon).

Definition at line 4953 of file game.cpp.

4954{
4955 return place_critter_around( id, p, 0 );
4956}

References place_critter_around().

Referenced by fungal_effects::fungalize(), revive_corpse(), fungal_effects::spread_fungus_one_tile(), and update_stair_monsters().

◆ place_critter_at() [2/2]

monster * game::place_critter_at ( const shared_ptr_fast< monster > &  mon,
const tripoint p 
)

Definition at line 4958 of file game.cpp.

4959{
4960 return place_critter_around( mon, p, 0 );
4961}

References place_critter_around().

◆ place_critter_within() [1/2]

monster * game::place_critter_within ( const mtype_id id,
const tripoint_range< tripoint > &  range 
)

Definition at line 4995 of file game.cpp.

4996{
4997 // TODO: change this into an assert, it must never happen.
4998 if( id.is_null() ) {
4999 return nullptr;
5000 }
5001 return place_critter_within( make_shared_fast<monster>( id ), range );
5002}
monster * place_critter_within(const mtype_id &id, const tripoint_range< tripoint > &range)
Definition: game.cpp:4995

References place_critter_within().

Referenced by place_critter_within().

◆ place_critter_within() [2/2]

monster * game::place_critter_within ( const shared_ptr_fast< monster > &  mon,
const tripoint_range< tripoint > &  range 
)

Definition at line 5004 of file game.cpp.

5006{
5007 const cata::optional<tripoint> where = choose_where_to_place_monster( *mon, range );
5008 if( !where ) {
5009 return nullptr;
5010 }
5011 mon->spawn( *where );
5012 return critter_tracker->add( mon ) ? mon.get() : nullptr;
5013}

References choose_where_to_place_monster(), and critter_tracker.

◆ place_player()

point game::place_player ( const tripoint dest)
Dexterity increases chance of avoiding cuts on sharp terrain

Definition at line 9631 of file game.cpp.

9632{
9633 const optional_vpart_position vp1 = m.veh_at( dest_loc );
9634 if( const cata::optional<std::string> label = vp1.get_label() ) {
9635 add_msg( m_info, _( "Label here: %s" ), *label );
9636 }
9637 std::string signage = m.get_signage( dest_loc );
9638 if( !signage.empty() ) {
9639 if( !u.has_trait( trait_ILLITERATE ) ) {
9640 add_msg( m_info, _( "The sign says: %s" ), signage );
9641 } else {
9642 add_msg( m_info, _( "There is a sign here, but you are unable to read it." ) );
9643 }
9644 }
9645 if( m.has_graffiti_at( dest_loc ) ) {
9646 if( !u.has_trait( trait_ILLITERATE ) ) {
9647 add_msg( m_info, _( "Written here: %s" ), m.graffiti_at( dest_loc ) );
9648 } else {
9649 add_msg( m_info, _( "Something is written here, but you are unable to read it." ) );
9650 }
9651 }
9652 // TODO: Move the stuff below to a Character method so that NPCs can reuse it
9653 if( m.has_flag( "ROUGH", dest_loc ) && ( !u.in_vehicle ) && ( !u.is_mounted() ) ) {
9654 if( one_in( 5 ) && u.get_armor_bash( bodypart_id( "foot_l" ) ) < rng( 2, 5 ) ) {
9655 add_msg( m_bad, _( "You hurt your left foot on the %s!" ),
9656 m.has_flag_ter( "ROUGH", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9657 dest_loc ) );
9658 u.deal_damage( nullptr, bodypart_id( "foot_l" ), damage_instance( DT_CUT, 1 ) );
9659 }
9660 if( one_in( 5 ) && u.get_armor_bash( bodypart_id( "foot_r" ) ) < rng( 2, 5 ) ) {
9661 add_msg( m_bad, _( "You hurt your right foot on the %s!" ),
9662 m.has_flag_ter( "ROUGH", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9663 dest_loc ) );
9664 u.deal_damage( nullptr, bodypart_id( "foot_l" ), damage_instance( DT_CUT, 1 ) );
9665 }
9666 }
9667 ///\EFFECT_DEX increases chance of avoiding cuts on sharp terrain
9668 if( m.has_flag( "SHARP", dest_loc ) && !one_in( 3 ) && !x_in_y( 1 + u.dex_cur / 2.0, 40 ) &&
9669 ( !u.in_vehicle && !m.veh_at( dest_loc ) ) && ( !u.has_trait( trait_PARKOUR ) ||
9670 one_in( 4 ) ) && ( u.has_trait( trait_THICKSKIN ) ? !one_in( 8 ) : true ) ) {
9671 if( u.is_mounted() ) {
9672 add_msg( _( "Your %s gets cut!" ), u.mounted_creature->get_name() );
9673 u.mounted_creature->apply_damage( nullptr, bodypart_id( "torso" ), rng( 1, 10 ) );
9674 } else {
9675 const bodypart_id bp = u.get_random_body_part();
9676 if( u.deal_damage( nullptr, bp, damage_instance( DT_CUT, rng( 1, 10 ) ) ).total_damage() > 0 ) {
9677 //~ 1$s - bodypart name in accusative, 2$s is terrain name.
9678 add_msg( m_bad, _( "You cut your %1$s on the %2$s!" ),
9679 body_part_name_accusative( bp->token ),
9680 m.has_flag_ter( "SHARP", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9681 dest_loc ) );
9682 }
9683 }
9684 }
9685 if( m.has_flag( "UNSTABLE", dest_loc ) && !u.is_mounted() ) {
9686 u.add_effect( effect_bouldering, 1_turns, num_bp );
9687 } else if( u.has_effect( effect_bouldering ) ) {
9689 }
9690 if( m.has_flag_ter_or_furn( TFLAG_NO_SIGHT, dest_loc ) ) {
9691 u.add_effect( effect_no_sight, 1_turns, num_bp );
9692 } else if( u.has_effect( effect_no_sight ) ) {
9694 }
9695
9696 // If we moved out of the nonant, we need update our map data
9697 if( m.has_flag( "SWIMMABLE", dest_loc ) && u.has_effect( effect_onfire ) ) {
9698 add_msg( _( "The water puts out the flames!" ) );
9700 if( u.is_mounted() ) {
9701 monster *mon = u.mounted_creature.get();
9702 if( mon->has_effect( effect_onfire ) ) {
9704 }
9705 }
9706 }
9707
9708 if( monster *const mon_ptr = critter_at<monster>( dest_loc ) ) {
9709 // We displaced a monster. It's probably a bug if it wasn't a friendly mon...
9710 // Immobile monsters can't be displaced.
9711 monster &critter = *mon_ptr;
9712 // TODO: handling for ridden creatures other than players mount.
9713 if( !critter.has_effect( effect_ridden ) ) {
9714 if( u.is_mounted() ) {
9715 std::vector<tripoint> valid;
9716 for( const tripoint &jk : m.points_in_radius( critter.pos(), 1 ) ) {
9717 if( is_empty( jk ) ) {
9718 valid.push_back( jk );
9719 }
9720 }
9721 if( !valid.empty() ) {
9722 critter.move_to( random_entry( valid ) );
9723 add_msg( _( "You push the %s out of the way." ), critter.name() );
9724 } else {
9725 add_msg( _( "There is no room to push the %s out of the way." ), critter.name() );
9726 return u.pos().xy();
9727 }
9728 } else {
9729 critter.move_to( u.pos(), false,
9730 true ); // Force the movement even though the player is there right now.
9731 add_msg( _( "You displace the %s." ), critter.name() );
9732 }
9733 } else if( !u.has_effect( effect_riding ) ) {
9734 add_msg( _( "You cannot move the %s out of the way." ), critter.name() );
9735 return u.pos().xy();
9736 }
9737 }
9738
9739 // If the player is in a vehicle, unboard them from the current part
9740 if( u.in_vehicle ) {
9741 m.unboard_vehicle( u.pos() );
9742 }
9743 // Move the player
9744 // Start with z-level, to make it less likely that old functions (2D ones) freak out
9745 if( m.has_zlevels() && dest_loc.z != get_levz() ) {
9746 vertical_shift( dest_loc.z );
9747 }
9748
9749 if( u.is_hauling() && ( !m.can_put_items( dest_loc ) ||
9750 m.has_flag( TFLAG_DEEP_WATER, dest_loc ) ||
9751 vp1 ) ) {
9752 u.stop_hauling();
9753 }
9754 u.setpos( dest_loc );
9755 if( u.is_mounted() ) {
9756 monster *mon = u.mounted_creature.get();
9757 mon->setpos( dest_loc );
9758 mon->process_triggers();
9759 m.creature_in_field( *mon );
9760 }
9761 point submap_shift = update_map( u );
9762 // Important: don't use dest_loc after this line. `update_map` may have shifted the map
9763 // and dest_loc was not adjusted and therefore is still in the un-shifted system and probably wrong.
9764 // If you must use it you can calculate the position in the new, shifted system with
9765 // adjusted_pos = ( old_pos.x - submap_shift.x * SEEX, old_pos.y - submap_shift.y * SEEY, old_pos.z )
9766
9767 //Auto pulp or butcher and Auto foraging
9768 if( get_option<bool>( "AUTO_FEATURES" ) && mostseen == 0 && !u.is_mounted() ) {
9770
9771 const std::string forage_type = get_option<std::string>( "AUTO_FORAGING" );
9772 if( forage_type != "off" ) {
9773 const auto forage = [&]( const tripoint & pos ) {
9774 const auto &xter_t = m.ter( pos ).obj().examine;
9775 const auto &xfurn_t = m.furn( pos ).obj().examine;
9776 const bool forage_everything = forage_type == "both";
9777 const bool forage_bushes = forage_everything || forage_type == "bushes";
9778 const bool forage_trees = forage_everything || forage_type == "trees";
9779 if( xter_t == &iexamine::none ) {
9780 return;
9781 } else if( ( forage_bushes && xter_t == &iexamine::shrub_marloss ) ||
9782 ( forage_bushes && xter_t == &iexamine::shrub_wildveggies ) ||
9783 ( forage_bushes && xter_t == &iexamine::harvest_ter_nectar ) ||
9784 ( forage_trees && xter_t == &iexamine::tree_marloss ) ||
9785 ( forage_trees && xter_t == &iexamine::harvest_ter ) ||
9786 ( forage_trees && xter_t == &iexamine::harvest_ter_nectar )
9787 ) {
9788 xter_t( u, pos );
9789 } else if( ( forage_everything && xfurn_t == &iexamine::harvest_furn ) ||
9790 ( forage_everything && xfurn_t == &iexamine::harvest_furn_nectar )
9791 ) {
9792 xfurn_t( u, pos );
9793 }
9794 };
9795
9796 for( auto &elem : adjacentDir ) {
9797 forage( u.pos() + direction_XY( elem ) );
9798 }
9799 }
9800
9801 const std::string pulp_butcher = get_option<std::string>( "AUTO_PULP_BUTCHER" );
9802 if( pulp_butcher == "butcher" && u.max_quality( quality_id( "BUTCHER" ) ) > INT_MIN ) {
9803 std::vector<item *> corpses;
9804
9805 for( item &it : m.i_at( u.pos() ) ) {
9806 corpses.push_back( &it );
9807 }
9808
9809 if( !corpses.empty() ) {
9810 u.assign_activity( activity_id( "ACT_BUTCHER" ), 0, true );
9811 for( item *it : corpses ) {
9812 u.activity.targets.emplace_back( map_cursor( u.pos() ), it );
9813 }
9814 }
9815 } else if( pulp_butcher == "pulp" || pulp_butcher == "pulp_adjacent" ) {
9816 const auto pulp = [&]( const tripoint & pos ) {
9817 for( const auto &maybe_corpse : m.i_at( pos ) ) {
9818 if( maybe_corpse.is_corpse() && maybe_corpse.can_revive() &&
9819 !maybe_corpse.get_mtype()->bloodType().obj().has_acid ) {
9821 u.activity.placement = m.getabs( pos );
9822 u.activity.auto_resume = true;
9823 u.activity.str_values.push_back( "auto_pulp_no_acid" );
9824 return;
9825 }
9826 }
9827 };
9828
9829 if( pulp_butcher == "pulp_adjacent" ) {
9830 for( auto &elem : adjacentDir ) {
9831 pulp( u.pos() + direction_XY( elem ) );
9832 }
9833 } else {
9834 pulp( u.pos() );
9835 }
9836 }
9837 }
9838
9839 //Autopickup
9840 if( !u.is_mounted() && get_option<bool>( "AUTO_PICKUP" ) && !u.is_hauling() &&
9841 ( !get_option<bool>( "AUTO_PICKUP_SAFEMODE" ) || mostseen == 0 ) &&
9842 ( m.has_items( u.pos() ) || get_option<bool>( "AUTO_PICKUP_ADJACENT" ) ) ) {
9843 pickup::pick_up( u.pos(), -1 );
9844 }
9845
9846 // If the new tile is a boardable part, board it
9847 if( vp1.part_with_feature( "BOARDABLE", true ) && !u.is_mounted() ) {
9848 m.board_vehicle( u.pos(), &u );
9849 }
9850
9851 // Traps!
9852 // Try to detect.
9854 if( u.is_mounted() ) {
9856 } else {
9857 m.creature_on_trap( u );
9858 }
9859 // Drench the player if swimmable
9860 if( m.has_flag( "SWIMMABLE", u.pos() ) &&
9861 !( u.is_mounted() || ( u.in_vehicle && vp1->vehicle().can_float() ) ) ) {
9862 u.drench( 40, { { bp_foot_l, bp_foot_r, bp_leg_l, bp_leg_r } }, false );
9863 }
9864
9865 // List items here
9866 if( !m.has_flag( "SEALED", u.pos() ) ) {
9867 if( get_option<bool>( "NO_AUTO_PICKUP_ZONES_LIST_ITEMS" ) ||
9868 !check_zone( zone_type_id( "NO_AUTO_PICKUP" ), u.pos() ) ) {
9869 if( u.is_blind() && !m.i_at( u.pos() ).empty() ) {
9870 add_msg( _( "There's something here, but you can't see what it is." ) );
9871 } else if( m.has_items( u.pos() ) ) {
9872 std::vector<std::string> names;
9873 std::vector<size_t> counts;
9874 std::vector<item> items;
9875 for( auto &tmpitem : m.i_at( u.pos() ) ) {
9876
9877 std::string next_tname = tmpitem.tname();
9878 std::string next_dname = tmpitem.display_name();
9879 bool by_charges = tmpitem.count_by_charges();
9880 bool got_it = false;
9881 for( size_t i = 0; i < names.size(); ++i ) {
9882 if( by_charges && next_tname == names[i] ) {
9883 counts[i] += tmpitem.charges;
9884 got_it = true;
9885 break;
9886 } else if( next_dname == names[i] ) {
9887 counts[i] += 1;
9888 got_it = true;
9889 break;
9890 }
9891 }
9892 if( !got_it ) {
9893 if( by_charges ) {
9894 names.push_back( tmpitem.tname( tmpitem.charges ) );
9895 counts.push_back( tmpitem.charges );
9896 } else {
9897 names.push_back( tmpitem.display_name( 1 ) );
9898 counts.push_back( 1 );
9899 }
9900 items.push_back( tmpitem );
9901 }
9902 if( names.size() > 10 ) {
9903 break;
9904 }
9905 }
9906 for( size_t i = 0; i < names.size(); ++i ) {
9907 if( !items[i].count_by_charges() ) {
9908 names[i] = items[i].display_name( counts[i] );
9909 } else {
9910 names[i] = items[i].tname( counts[i] );
9911 }
9912 }
9913 int and_the_rest = 0;
9914 for( size_t i = 0; i < names.size(); ++i ) {
9915 //~ number of items: "<number> <item>"
9916 std::string fmt = vgettext( "%1$d %2$s", "%1$d %2$s", counts[i] );
9917 names[i] = string_format( fmt, counts[i], names[i] );
9918 // Skip the first two.
9919 if( i > 1 ) {
9920 and_the_rest += counts[i];
9921 }
9922 }
9923 if( names.size() == 1 ) {
9924 add_msg( _( "You see here %s." ), names[0] );
9925 } else if( names.size() == 2 ) {
9926 add_msg( _( "You see here %s and %s." ), names[0], names[1] );
9927 } else if( names.size() == 3 ) {
9928 add_msg( _( "You see here %s, %s, and %s." ), names[0], names[1], names[2] );
9929 } else if( and_the_rest < 7 ) {
9930 add_msg( vgettext( "You see here %s, %s and %d more item.",
9931 "You see here %s, %s and %d more items.",
9932 and_the_rest ),
9933 names[0], names[1], and_the_rest );
9934 } else {
9935 add_msg( _( "You see here %s and many more items." ), names[0] );
9936 }
9937 }
9938 }
9939 }
9940
9941 if( ( vp1.part_with_feature( "CONTROL_ANIMAL", true ) ||
9942 vp1.part_with_feature( "CONTROLS", true ) ) && u.in_vehicle && !u.is_mounted() ) {
9943 add_msg( _( "There are vehicle controls here." ) );
9944 if( !u.has_trait( trait_id( "WAYFARER" ) ) ) {
9945 add_msg( m_info, _( "%s to drive." ), press_x( ACTION_CONTROL_VEHICLE ) );
9946 }
9947 } else if( vp1.part_with_feature( "CONTROLS", true ) && u.in_vehicle &&
9948 u.is_mounted() ) {
9949 add_msg( _( "There are vehicle controls here but you cannot reach them whilst mounted." ) );
9950 }
9951 return submap_shift;
9952}
std::string body_part_name_accusative(body_part bp, int number)
Returns the matching accusative name of the body_part token, i.e.
Definition: bodypart.cpp:329
void drench(int saturation, const body_part_set &flags, bool ignore_waterproof)
Drenches the player with water, saturation is the percent gotten wet.
Definition: suffer.cpp:1755
bool is_hauling() const
Definition: character.cpp:9175
void stop_hauling()
Definition: character.cpp:9166
bodypart_id get_random_body_part(bool main=false) const
Definition: creature.cpp:1617
void vertical_shift(int z_after)
Actual z-level movement part of vertical_move.
Definition: game.cpp:11092
bool check_zone(const zone_type_id &type, const tripoint &where) const
Definition: game.cpp:6284
std::string furnname(const tripoint &p)
Definition: map.cpp:1463
bool has_flag_ter_or_furn(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2316
bool has_graffiti_at(const tripoint &p) const
Definition: map.cpp:7696
bool has_items(const tripoint &p) const
Checks for existence of items.
Definition: map.cpp:4774
const std::string & graffiti_at(const tripoint &p) const
Definition: map.cpp:7685
bool has_flag_ter(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2306
bool can_put_items(const tripoint &p) const
Definition: map.cpp:2292
void setpos(const tripoint &p) override
Definition: monster.cpp:237
bool move_to(const tripoint &p, bool force=false, bool step_on_critter=false, float stagger_adjustment=1.0)
Attempt to move to p.
Definition: monmove.cpp:1493
void process_triggers()
Definition: monster.cpp:1192
cata::optional< std::string > get_label() const
std::vector< std::string > str_values
bool auto_resume
If true, the activity will be auto-resumed next time the player attempts an identical activity.
void search_surroundings()
Search surrounding squares for traps (and maybe other things in the future).
Definition: player.cpp:848
static const efftype_id effect_riding("riding")
static const trait_id trait_ILLITERATE("ILLITERATE")
static const efftype_id effect_bouldering("bouldering")
static const trait_id trait_PARKOUR("PARKOUR")
static const efftype_id effect_no_sight("no_sight")
static const trait_id trait_THICKSKIN("THICKSKIN")
static const efftype_id effect_onfire("onfire")
point direction_XY(const direction dir)
Definition: line.cpp:433
@ TFLAG_NO_SIGHT
Definition: mapdata.h:283
@ TFLAG_DEEP_WATER
Definition: mapdata.h:301
static std::map< nameFlags, std::vector< std::string > > names
Definition: name.cpp:18
const int INDEFINITELY_LONG
A number that represents the longest possible action.
void shrub_wildveggies(player &p, const tripoint &examp)
Definition: iexamine.cpp:3655
void shrub_marloss(player &p, const tripoint &examp)
Definition: iexamine.cpp:3620
void harvest_ter(player &p, const tripoint &examp)
Definition: iexamine.cpp:2042
void harvest_furn(player &p, const tripoint &examp)
Definition: iexamine.cpp:2021
void harvest_ter_nectar(player &p, const tripoint &examp)
Definition: iexamine.cpp:2030
void harvest_furn_nectar(player &p, const tripoint &examp)
Definition: iexamine.cpp:2012
void tree_marloss(player &p, const tripoint &examp)
Definition: iexamine.cpp:3634
string_id< zone_type > zone_type_id
Definition: type_id.h:189

References _, ACTION_CONTROL_VEHICLE, Character::activity, Creature::add_effect(), add_msg(), Character::assign_activity(), player_activity::auto_resume, map::board_vehicle(), body_part_name_accusative(), bp_foot_l, bp_foot_r, bp_leg_l, bp_leg_r, map::can_put_items(), check_zone(), map::creature_in_field(), map::creature_on_trap(), Character::deal_damage(), Character::dex_cur, direction_XY(), Character::drench(), DT_CUT, EAST, effect_bouldering, effect_no_sight, effect_onfire, effect_ridden, effect_riding, item_stack::empty(), map_data_common_t::examine, map::furn(), map::furnname(), Character::get_armor_bash(), optional_vpart_position::get_label(), get_levz(), Creature::get_random_body_part(), map::get_signage(), map::getabs(), map::graffiti_at(), iexamine::harvest_furn(), iexamine::harvest_furn_nectar(), iexamine::harvest_ter(), iexamine::harvest_ter_nectar(), Creature::has_effect(), map::has_flag(), map::has_flag_ter(), map::has_flag_ter_or_furn(), map::has_graffiti_at(), map::has_items(), Character::has_trait(), map::has_zlevels(), map::i_at(), Character::in_vehicle, calendar::INDEFINITELY_LONG, Character::is_blind(), is_empty(), Character::is_hauling(), Character::is_mounted(), m, m_bad, m_info, visitable< T >::max_quality(), mostseen, Character::mounted_creature, monster::move_to(), monster::name(), Name::names, iexamine::none(), NORTH, NORTHEAST, NORTHWEST, num_bp, int_id< T >::obj(), one_in(), optional_vpart_position::part_with_feature(), pickup::pick_up(), player_activity::placement, map::points_in_radius(), Character::pos(), monster::pos(), press_x(), monster::process_triggers(), random_entry(), Creature::remove_effect(), rng(), player::search_surroundings(), Character::setpos(), monster::setpos(), iexamine::shrub_marloss(), iexamine::shrub_wildveggies(), SOUTH, SOUTHEAST, SOUTHWEST, Character::stop_hauling(), player_activity::str_values, string_format(), player_activity::targets, map::ter(), map::tername(), TFLAG_DEEP_WATER, TFLAG_NO_SIGHT, trait_ILLITERATE, trait_PARKOUR, trait_THICKSKIN, iexamine::tree_marloss(), u, map::unboard_vehicle(), update_map(), map::veh_at(), vertical_shift(), vgettext(), WEST, x_in_y(), tripoint::xy(), and tripoint::z.

Referenced by place_player_overmap(), and walk_move().

◆ place_player_overmap()

void game::place_player_overmap ( const tripoint_abs_omt om_dest)

Definition at line 9954 of file game.cpp.

9955{
9956 // if player is teleporting around, they don't bring their horse with them
9957 if( u.is_mounted() ) {
9959 u.mounted_creature->remove_effect( effect_ridden );
9960 u.mounted_creature = nullptr;
9961 }
9962 // offload the active npcs.
9963 unload_npcs();
9964 for( monster &critter : all_monsters() ) {
9965 despawn_monster( critter );
9966 }
9967 if( u.in_vehicle ) {
9968 m.unboard_vehicle( u.pos() );
9969 }
9970
9972 const int minz = m.has_zlevels() ? -OVERMAP_DEPTH : get_levz();
9973 const int maxz = m.has_zlevels() ? OVERMAP_HEIGHT : get_levz();
9974 for( int z = minz; z <= maxz; z++ ) {
9975 m.clear_vehicle_list( z );
9976 }
9978 // offset because load_map expects the coordinates of the top left corner, but the
9979 // player will be centered in the middle of the map.
9980 // TODO: fix point types
9981 const tripoint map_sm_pos(
9982 project_to<coords::sm>( om_dest ).raw() + point( -HALF_MAPSIZE, -HALF_MAPSIZE ) );
9983 const tripoint player_pos( u.pos().xy(), map_sm_pos.z );
9984 load_map( map_sm_pos );
9985 load_npcs();
9986 m.spawn_monsters( true ); // Static monsters
9988 // update weather now as it could be different on the new location
9990 place_player( player_pos );
9991}
point place_player(const tripoint &dest)
Definition: game.cpp:9631
void unload_npcs()
Unloads all NPCs.
Definition: game.cpp:949
void update_overmap_seen()
Definition: game.cpp:11270
level_cache & access_cache(int zlev)
Definition: map.cpp:8527
void clear_vehicle_list(int zlev)
Definition: map.cpp:326
void clear_vehicle_cache()
Definition: map.cpp:308
std::bitset< MAPSIZE_X *MAPSIZE_Y > map_memory_seen_cache
Definition: map.h:339

References map::access_cache(), all_monsters(), map::clear_vehicle_cache(), map::clear_vehicle_list(), despawn_monster(), effect_ridden, effect_riding, get_levz(), get_weather, HALF_MAPSIZE, map::has_zlevels(), Character::in_vehicle, Character::is_mounted(), load_map(), load_npcs(), m, level_cache::map_memory_seen_cache, Character::mounted_creature, weather_manager::nextweather, OVERMAP_DEPTH, OVERMAP_HEIGHT, place_player(), Character::pos(), Creature::remove_effect(), map::spawn_monsters(), calendar::turn, u, map::unboard_vehicle(), unload_npcs(), update_overmap_seen(), tripoint::xy(), and tripoint::z.

◆ place_vehicle_nearby()

vehicle * game::place_vehicle_nearby ( const vproto_id id,
const point_abs_omt origin,
int  min_distance,
int  max_distance,
const std::vector< std::string > &  omt_search_types = {} 
)
private

Definition at line 845 of file game.cpp.

848{
849 std::vector<std::string> search_types = omt_search_types;
850 if( search_types.empty() ) {
851 vehicle veh( id );
852 if( veh.can_float() ) {
853 search_types.push_back( "river" );
854 search_types.push_back( "lake" );
855 } else {
856 search_types.push_back( "field" );
857 search_types.push_back( "road" );
858 }
859 }
860 for( const std::string &search_type : search_types ) {
861 omt_find_params find_params;
862 find_params.must_see = false;
863 find_params.cant_see = false;
864 find_params.types.emplace_back( search_type, ot_match_type::type );
865 // find nearest road
866 find_params.min_distance = min_distance;
867 find_params.search_range = max_distance;
868 // if player spawns underground, park their car on the surface.
869 const tripoint_abs_omt omt_origin( origin, 0 );
870 for( const tripoint_abs_omt &goal : overmap_buffer.find_all( omt_origin, find_params ) ) {
871 // try place vehicle there.
872 tinymap target_map;
873 target_map.load( project_to<coords::sm>( goal ), false );
874 const tripoint tinymap_center( SEEX, SEEY, goal.z() );
875 static constexpr std::array<units::angle, 4> angles = {{
876 0_degrees, 90_degrees, 180_degrees, 270_degrees
877 }
878 };
879 vehicle *veh = target_map.add_vehicle(
880 id, tinymap_center, random_entry( angles ), rng( 50, 80 ), 0, false );
881 if( veh ) {
882 tripoint abs_local = m.getlocal( target_map.getabs( tinymap_center ) );
883 veh->sm_pos = ms_to_sm_remain( abs_local );
884 veh->pos = abs_local.xy();
886 veh->tracking_on = true;
887 target_map.save();
888 return veh;
889 }
890 }
891 }
892 return nullptr;
893}
void save()
Add currently loaded submaps (in grid) to the mapbuffer.
Definition: map.cpp:6484
vehicle * add_vehicle(const vgroup_id &type, const tripoint &p, units::angle dir, int init_veh_fuel=-1, int init_veh_status=-1, bool merge_wrecks=true)
Definition: mapgen.cpp:5600
void add_vehicle(vehicle *veh)
Add the vehicle to be tracked in the overmap.
std::vector< tripoint_abs_omt > find_all(const tripoint_abs_omt &origin, const omt_find_params &params)
Find all places with the specific overmap terrain type.
Definition: map.h:2065
point pos
Position of the vehicle inside the submap that contains the vehicle.
Definition: vehicle.h:1897
tripoint sm_pos
Submap coordinates of the currently loaded submap (see game::m) that contains this vehicle.
Definition: vehicle.h:1882
bool tracking_on
Definition: vehicle.h:1972
point ms_to_sm_remain(int &x, int &y)
static constexpr int SEEY
Standard arguments for finding overmap terrain.
std::vector< std::pair< std::string, ot_match_type > > types

References map::add_vehicle(), overmapbuffer::add_vehicle(), vehicle::can_float(), omt_find_params::cant_see, overmapbuffer::find_all(), map::getabs(), map::getlocal(), map::load(), m, omt_find_params::min_distance, ms_to_sm_remain(), omt_find_params::must_see, overmap_buffer, vehicle::pos, random_entry(), rng(), map::save(), omt_find_params::search_range, SEEX, SEEY, vehicle::sm_pos, vehicle::tracking_on, type, omt_find_params::types, and tripoint::xy().

Referenced by start_game().

◆ pre_print_all_tile_info()

void game::pre_print_all_tile_info ( const tripoint lp,
const catacurses::window w_info,
int &  line,
int  last_line,
const visibility_variables cache 
)

Definition at line 6826 of file game.cpp.

6829{
6830 // get global area info according to look_around caret position
6831 // TODO: fix point types
6833 lp ) ) ) );
6834 // we only need the area name and then pass it to print_all_tile_info() function below
6835 const std::string area_name = cur_ter_m->get_name();
6836 print_all_tile_info( lp, w_info, area_name, 1, first_line, last_line, cache );
6837}
void print_all_tile_info(const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line, int last_line, const visibility_variables &cache)
Definition: game.cpp:6006
point ms_to_omt_copy(const point &p)
coords::coord_point< tripoint, coords::origin::abs, coords::omt > tripoint_abs_omt
Definition: coordinates.h:493
std::string get_name() const
Definition: omdata.h:209

References oter_t::get_name(), map::getabs(), m, ms_to_omt_copy(), overmap_buffer, print_all_tile_info(), and overmapbuffer::ter().

Referenced by look_around().

◆ print_all_tile_info()

void game::print_all_tile_info ( const tripoint lp,
const catacurses::window w_look,
const std::string &  area_name,
int  column,
int &  line,
int  last_line,
const visibility_variables cache 
)

Definition at line 6006 of file game.cpp.

6011{
6012 visibility_type visibility = VIS_HIDDEN;
6013 const bool inbounds = m.inbounds( lp );
6014 if( inbounds ) {
6015 visibility = m.get_visibility( m.apparent_light_at( lp, cache ), cache );
6016 }
6017 const Creature *creature = critter_at( lp, true );
6018 switch( visibility ) {
6019 case VIS_CLEAR: {
6020 const optional_vpart_position vp = m.veh_at( lp );
6021 print_terrain_info( lp, w_look, area_name, column, line );
6022 print_fields_info( lp, w_look, column, line );
6023 print_trap_info( lp, w_look, column, line );
6024 print_creature_info( creature, w_look, column, line, last_line );
6025 print_vehicle_info( veh_pointer_or_null( vp ), vp ? vp->part_index() : -1, w_look, column, line,
6026 last_line );
6027 print_items_info( lp, w_look, column, line, last_line );
6028 print_graffiti_info( lp, w_look, column, line, last_line );
6029 }
6030 break;
6031 case VIS_BOOMER:
6032 case VIS_BOOMER_DARK:
6033 case VIS_DARK:
6034 case VIS_LIT:
6035 case VIS_HIDDEN:
6036 print_visibility_info( w_look, column, line, visibility );
6037
6038 if( creature != nullptr ) {
6039 std::vector<std::string> buf;
6040 if( u.sees_with_infrared( *creature ) ) {
6041 creature->describe_infrared( buf );
6042 } else if( u.sees_with_specials( *creature ) ) {
6043 creature->describe_specials( buf );
6044 }
6045 for( const std::string &s : buf ) {
6046 mvwprintw( w_look, point( 1, ++line ), s );
6047 }
6048 }
6049 break;
6050 }
6051 if( !inbounds ) {
6052 return;
6053 }
6054 auto this_sound = sounds::sound_at( lp );
6055 if( !this_sound.empty() ) {
6056 mvwprintw( w_look, point( 1, ++line ), _( "You heard %s from here." ), this_sound );
6057 } else {
6058 // Check other z-levels
6059 tripoint tmp = lp;
6060 for( tmp.z = -OVERMAP_DEPTH; tmp.z <= OVERMAP_HEIGHT; tmp.z++ ) {
6061 if( tmp.z == lp.z ) {
6062 continue;
6063 }
6064
6065 auto zlev_sound = sounds::sound_at( tmp );
6066 if( !zlev_sound.empty() ) {
6067 mvwprintw( w_look, point( 1, ++line ), tmp.z > lp.z ?
6068 _( "You heard %s from above." ) : _( "You heard %s from below." ), zlev_sound );
6069 }
6070 }
6071 }
6072}
bool sees_with_specials(const Creature &critter) const
Definition: character.cpp:6417
bool sees_with_infrared(const Creature &critter) const
Check whether the this player can see the other creature with infrared.
void print_fields_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line)
Definition: game.cpp:6176
void print_terrain_info(const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line)
Definition: game.cpp:6103
void print_graffiti_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6268
void print_creature_info(const Creature *creature, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6213
void print_vehicle_info(const vehicle *veh, int veh_part, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6222
void print_items_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6231
void print_visibility_info(const catacurses::window &w_look, int column, int &line, visibility_type visibility)
Definition: game.cpp:6074
void print_trap_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line)
Definition: game.cpp:6194
void line(map *m, const ter_id &type, const point &p1, const point &p2)
Definition: mapgen.cpp:6455
std::string sound_at(const tripoint &location)
Definition: sounds.cpp:605

References _, map::apparent_light_at(), creature, critter_at(), map::get_visibility(), map::inbounds(), line(), m, catacurses::mvwprintw(), OVERMAP_DEPTH, OVERMAP_HEIGHT, print_creature_info(), print_fields_info(), print_graffiti_info(), print_items_info(), print_terrain_info(), print_trap_info(), print_vehicle_info(), print_visibility_info(), Character::sees_with_infrared(), Character::sees_with_specials(), sounds::sound_at(), u, map::veh_at(), veh_pointer_or_null(), VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, VIS_LIT, and tripoint::z.

Referenced by pre_print_all_tile_info().

◆ print_creature_info()

void game::print_creature_info ( const Creature creature,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6213 of file game.cpp.

6215{
6216 int vLines = last_line - line;
6217 if( creature != nullptr && ( u.sees( *creature ) || creature == &u ) ) {
6218 line = creature->print_info( w_look, ++line, vLines, column );
6219 }
6220}

References creature, line(), Character::sees(), and u.

Referenced by print_all_tile_info().

◆ print_fields_info()

void game::print_fields_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line 
)
private

Definition at line 6176 of file game.cpp.

6178{
6179 const field &tmpfield = m.field_at( lp );
6180 for( auto &fld : tmpfield ) {
6181 const field_entry &cur = fld.second;
6182 if( fld.first.obj().has_fire && ( m.has_flag( TFLAG_FIRE_CONTAINER, lp ) ||
6183 m.ter( lp ) == t_pit_shallow || m.ter( lp ) == t_pit ) ) {
6184 const int max_width = getmaxx( w_look ) - column - 2;
6185 int lines = fold_and_print( w_look, point( column, ++line ), max_width, cur.color(),
6186 get_fire_fuel_string( lp ) ) - 1;
6187 line += lines;
6188 } else {
6189 mvwprintz( w_look, point( column, ++line ), cur.color(), cur.name() );
6190 }
6191 }
6192}
An active or passive effect existing on a tile.
Definition: field.h:20
nc_color color() const
Definition: field.cpp:94
std::string name() const
Definition: field.h:84
A variable sized collection of field entries on a given map square.
Definition: field.h:131
ter_id t_pit_shallow
Definition: mapdata.cpp:625
ter_id t_pit
Definition: mapdata.cpp:625

References field_entry::color(), map::field_at(), fold_and_print(), get_fire_fuel_string(), catacurses::getmaxx(), map::has_flag(), line(), m, mvwprintz(), field_entry::name(), t_pit, t_pit_shallow, map::ter(), and TFLAG_FIRE_CONTAINER.

Referenced by print_all_tile_info().

◆ print_graffiti_info()

void game::print_graffiti_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6268 of file game.cpp.

6271{
6272 if( line > last_line ) {
6273 return;
6274 }
6275
6276 const int max_width = getmaxx( w_look ) - column - 2;
6277 if( m.has_graffiti_at( lp ) ) {
6278 fold_and_print( w_look, point( column, ++line ), max_width, c_light_gray,
6279 m.ter( lp ) == t_grave_new ? _( "Graffiti: %s" ) : _( "Inscription: %s" ),
6280 m.graffiti_at( lp ) );
6281 }
6282}
ter_id t_grave_new
Definition: mapdata.cpp:625

References _, c_light_gray, fold_and_print(), catacurses::getmaxx(), map::graffiti_at(), map::has_graffiti_at(), line(), m, t_grave_new, and map::ter().

Referenced by print_all_tile_info().

◆ print_items_info()

void game::print_items_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6231 of file game.cpp.

6234{
6235 if( !m.sees_some_items( lp, u ) ) {
6236 return;
6237 } else if( m.has_flag( "CONTAINER", lp ) && !m.could_see_items( lp, u ) ) {
6238 mvwprintw( w_look, point( column, ++line ), _( "You cannot see what is inside of it." ) );
6239 } else if( u.has_effect( effect_blind ) || u.worn_with_flag( "BLIND" ) ) {
6240 mvwprintz( w_look, point( column, ++line ), c_yellow,
6241 _( "There's something there, but you can't see what it is." ) );
6242 return;
6243 } else {
6244 std::map<std::string, int> item_names;
6245 for( auto &item : m.i_at( lp ) ) {
6246 ++item_names[item.tname()];
6247 }
6248
6249 const int max_width = getmaxx( w_look ) - column - 1;
6250 for( auto it = item_names.begin(); it != item_names.end(); ++it ) {
6251 // last line but not last item
6252 if( line + 1 >= last_line && std::next( it ) != item_names.end() ) {
6253 mvwprintz( w_look, point( column, ++line ), c_yellow, _( "More items here…" ) );
6254 break;
6255 }
6256
6257 if( it->second > 1 ) {
6258 trim_and_print( w_look, point( column, ++line ), max_width, c_white,
6259 pgettext( "%s is the name of the item. %d is the quantity of that item.", "%s [%d]" ),
6260 it->first.c_str(), it->second );
6261 } else {
6262 trim_and_print( w_look, point( column, ++line ), max_width, c_white, it->first );
6263 }
6264 }
6265 }
6266}
bool could_see_items(const tripoint &p, const Creature &who) const
Check if the creature could see items at p if there were any items.
Definition: map.cpp:4750
static const efftype_id effect_blind("blind")

References _, c_white, c_yellow, map::could_see_items(), effect_blind, catacurses::getmaxx(), Creature::has_effect(), map::has_flag(), map::i_at(), line(), m, catacurses::mvwprintw(), mvwprintz(), pgettext(), map::sees_some_items(), item::tname(), trim_and_print(), u, and Character::worn_with_flag().

Referenced by print_all_tile_info().

◆ print_terrain_info()

void game::print_terrain_info ( const tripoint lp,
const catacurses::window w_look,
const std::string &  area_name,
int  column,
int &  line 
)
private

Definition at line 6103 of file game.cpp.

6106{
6107 const int max_width = getmaxx( w_look ) - column - 1;
6108 int lines;
6109
6110 const auto fmt_tile_info = []( const tripoint & lp ) {
6111 map &here = get_map();
6112 std::string ret;
6113 if( debug_mode ) {
6114 ret = string_format( "%s %s", lp.to_string(), here.ter( lp )->id );
6115 if( here.has_furn( lp ) ) {
6116 ret += "; " + here.furn( lp )->id.str();
6117 }
6118 } else {
6119 ret = here.tername( lp );
6120 if( here.has_furn( lp ) ) {
6121 ret += "; " + here.furnname( lp );
6122 }
6123 }
6124 return ret;
6125 };
6126
6127 std::string tile = string_format( "(%s) %s", area_name, fmt_tile_info( lp ) );
6128
6129 if( m.impassable( lp ) ) {
6130 lines = fold_and_print( w_look, point( column, line ), max_width, c_light_gray,
6131 _( "%s; Impassable" ),
6132 tile );
6133 } else {
6134 lines = fold_and_print( w_look, point( column, line ), max_width, c_light_gray,
6135 _( "%s; Movement cost %d" ),
6136 tile, m.move_cost( lp ) * 50 );
6137
6138 const auto ll = get_light_level( std::max( 1.0,
6139 LIGHT_AMBIENT_LIT - m.ambient_light_at( lp ) + 1.0 ) );
6140 mvwprintw( w_look, point( column, ++lines ), _( "Lighting: " ) );
6141 wprintz( w_look, ll.second, ll.first );
6142 }
6143
6144 std::string signage = m.get_signage( lp );
6145 if( !signage.empty() ) {
6146 trim_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
6147 // NOLINTNEXTLINE(cata-text-style): the question mark does not end a sentence
6148 u.has_trait( trait_ILLITERATE ) ? _( "Sign: ???" ) : _( "Sign: %s" ), signage );
6149 }
6150
6151 if( m.has_zlevels() && lp.z > -OVERMAP_DEPTH && !m.has_floor( lp ) ) {
6152 // Print info about stuff below
6153 tripoint below( lp.xy(), lp.z - 1 );
6154 std::string tile_below = fmt_tile_info( below );
6155
6156 if( !m.has_floor_or_support( lp ) ) {
6157 fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
6158 _( "Below: %s; No support" ),
6159 tile_below );
6160 } else {
6161 fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
6162 _( "Below: %s; Walkable" ),
6163 tile_below );
6164 }
6165 }
6166
6167 int map_features = fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
6168 m.features( lp ) );
6169 fold_and_print( w_look, point( column, ++lines ), max_width, c_light_gray, _( "Coverage: %d%%" ),
6170 m.coverage( lp ) );
6171 if( line < lines ) {
6172 line = lines + map_features - 1;
6173 }
6174}
Manage and cache data about a part of the map.
Definition: map.h:372
bool has_floor_or_support(const tripoint &p) const
Definition: map.cpp:2033
float ambient_light_at(const tripoint &p) const
Definition: lightmap.cpp:615
std::string features(const tripoint &p)
Definition: map.cpp:1708
int coverage(const tripoint &p) const
Returns coverage value of the tile.
Definition: map.cpp:6215
const std::string & str() const
Returns the identifier as plain std::string.
Definition: string_id.h:255
static constexpr float LIGHT_AMBIENT_LIT
Definition: lightmap.h:18
std::pair< std::string, nc_color > get_light_level(const float light)
Definition: output.cpp:1621
furn_str_id id
Definition: mapdata.h:490
ter_str_id id
Definition: mapdata.h:458

References _, map::ambient_light_at(), c_dark_gray, c_light_gray, map::coverage(), debug_mode, map::features(), fold_and_print(), map::furn(), map::furnname(), get_light_level(), get_map, map::get_signage(), catacurses::getmaxx(), map::has_floor(), map::has_floor_or_support(), map::has_furn(), Character::has_trait(), map::has_zlevels(), ter_t::id, furn_t::id, map::impassable(), LIGHT_AMBIENT_LIT, line(), m, map::move_cost(), catacurses::mvwprintw(), OVERMAP_DEPTH, cata::hash64_detail::ret, string_id< T >::str(), string_format(), map::ter(), map::tername(), tripoint::to_string(), trait_ILLITERATE, trim_and_print(), u, wprintz(), tripoint::xy(), and tripoint::z.

Referenced by print_all_tile_info().

◆ print_trap_info()

void game::print_trap_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line 
)
private

Definition at line 6194 of file game.cpp.

6196{
6197 const trap &tr = m.tr_at( lp );
6198 if( tr.can_see( lp, u ) ) {
6199 partial_con *pc = m.partial_con_at( lp );
6200 std::string tr_name;
6201 if( pc && tr.loadid == tr_unfinished_construction ) {
6202 const construction &built = pc->id.obj();
6203 tr_name = string_format( _( "Unfinished task: %s, %d%% complete" ), built.description,
6204 pc->counter / 100000 );
6205 } else {
6206 tr_name = tr.name();
6207 }
6208
6209 mvwprintz( w_look, point( column, ++line ), tr.color, tr_name );
6210 }
6211}
partial_con * partial_con_at(const tripoint &p)
Definition: map.cpp:5136
static const trap_str_id tr_unfinished_construction("tr_unfinished_construction")
std::string description
Definition: construction.h:51
construction_id id
Definition: construction.h:33
nc_color color
Definition: trap.h:93

References _, trap::can_see(), trap::color, partial_con::counter, construction::description, partial_con::id, line(), trap::loadid, m, mvwprintz(), trap::name(), int_id< T >::obj(), map::partial_con_at(), string_format(), map::tr_at(), tr_unfinished_construction, and u.

Referenced by print_all_tile_info().

◆ print_vehicle_info()

void game::print_vehicle_info ( const vehicle veh,
int  veh_part,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6222 of file game.cpp.

6224{
6225 if( veh ) {
6226 mvwprintw( w_look, point( column, ++line ), _( "There is a %s there. Parts:" ), veh->name );
6227 line = veh->print_part_list( w_look, ++line, last_line, getmaxx( w_look ), veh_part );
6228 }
6229}
int print_part_list(const catacurses::window &win, int y1, int max_y, int width, int p, int hl=-1, bool detail=false) const
Prints a list of all parts to the screen inside of a boxed window, possibly highlighting a selected o...

References _, catacurses::getmaxx(), line(), catacurses::mvwprintw(), vehicle::name, and vehicle::print_part_list().

Referenced by print_all_tile_info().

◆ print_visibility_info()

void game::print_visibility_info ( const catacurses::window w_look,
int  column,
int &  line,
visibility_type  visibility 
)
private

Definition at line 6074 of file game.cpp.

6076{
6077 const char *visibility_message = nullptr;
6078 switch( visibility ) {
6079 case VIS_CLEAR:
6080 visibility_message = _( "Clearly visible." );
6081 break;
6082 case VIS_BOOMER:
6083 visibility_message = _( "A bright pink blur." );
6084 break;
6085 case VIS_BOOMER_DARK:
6086 visibility_message = _( "A pink blur." );
6087 break;
6088 case VIS_DARK:
6089 visibility_message = _( "Darkness." );
6090 break;
6091 case VIS_LIT:
6092 visibility_message = _( "Bright light." );
6093 break;
6094 case VIS_HIDDEN:
6095 visibility_message = _( "Unseen." );
6096 break;
6097 }
6098
6099 mvwprintw( w_look, point( line, column ), visibility_message );
6100 line += 2;
6101}

References _, line(), catacurses::mvwprintw(), VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, and VIS_LIT.

Referenced by print_all_tile_info().

◆ process_activity()

void game::process_activity ( )
private

Definition at line 1740 of file game.cpp.

1741{
1742 if( !u.activity ) {
1743 return;
1744 }
1745
1746 while( u.moves > 0 && u.activity ) {
1747 u.activity.do_turn( u );
1748 }
1749}
void do_turn(player &p)
Performs the activity for a single turn.

References Character::activity, player_activity::do_turn(), Creature::moves, and u.

Referenced by do_turn().

◆ process_artifact()

void game::process_artifact ( item it,
player p 
)

Definition at line 11843 of file game.cpp.

11844{
11845 const bool worn = p.is_worn( it );
11846 const bool wielded = ( &it == &p.weapon );
11847 std::vector<art_effect_passive> effects = it.type->artifact->effects_carried;
11848 if( worn ) {
11849 const std::vector<art_effect_passive> &ew = it.type->artifact->effects_worn;
11850 effects.insert( effects.end(), ew.begin(), ew.end() );
11851 }
11852 if( wielded ) {
11853 const std::vector<art_effect_passive> &ew = it.type->artifact->effects_wielded;
11854 effects.insert( effects.end(), ew.begin(), ew.end() );
11855 }
11856
11857 if( it.is_tool() ) {
11858 // Recharge it if necessary
11859 if( it.ammo_remaining() < it.ammo_capacity() && calendar::once_every( 1_minutes ) ) {
11860 //Before incrementing charge, check that any extra requirements are met
11861 if( check_art_charge_req( it ) ) {
11862 switch( it.type->artifact->charge_type ) {
11863 case ARTC_NULL:
11864 case NUM_ARTCS:
11865 break; // dummy entries
11866 case ARTC_TIME:
11867 // Once per hour
11868 if( calendar::once_every( 1_hours ) ) {
11869 it.charges++;
11870 }
11871 break;
11872 case ARTC_SOLAR:
11873 if( calendar::once_every( 10_minutes ) &&
11874 is_in_sunlight( p.pos() ) ) {
11875 it.charges++;
11876 }
11877 break;
11878 // Artifacts can inflict pain even on Deadened folks.
11879 // Some weird Lovecraftian thing. ;P
11880 // (So DON'T route them through mod_pain!)
11881 case ARTC_PAIN:
11882 if( calendar::once_every( 1_minutes ) ) {
11883 add_msg( m_bad, _( "You suddenly feel sharp pain for no reason." ) );
11884 p.mod_pain_noresist( 3 * rng( 1, 3 ) );
11885 it.charges++;
11886 }
11887 break;
11888 case ARTC_HP:
11889 if( calendar::once_every( 1_minutes ) ) {
11890 add_msg( m_bad, _( "You feel your body decaying." ) );
11891 p.hurtall( 1, nullptr );
11892 it.charges++;
11893 }
11894 break;
11895 case ARTC_FATIGUE:
11896 if( calendar::once_every( 1_minutes ) ) {
11897 add_msg( m_bad, _( "You feel fatigue seeping into your body." ) );
11898 u.mod_fatigue( 3 * rng( 1, 3 ) );
11899 u.mod_stamina( -90 * rng( 1, 3 ) * rng( 1, 3 ) * rng( 2, 3 ) );
11900 it.charges++;
11901 }
11902 break;
11903 // Portals are energetic enough to charge the item.
11904 // Tears in reality are consumed too, but can't charge it.
11905 case ARTC_PORTAL:
11906 for( const tripoint &dest : m.points_in_radius( p.pos(), 1 ) ) {
11907 m.remove_field( dest, fd_fatigue );
11908 if( m.tr_at( dest ).loadid == tr_portal ) {
11909 add_msg( m_good, _( "The portal collapses!" ) );
11910 m.remove_trap( dest );
11911 it.charges++;
11912 break;
11913 }
11914 }
11915 break;
11916 }
11917 }
11918 }
11919 }
11920
11921 for( const art_effect_passive &i : effects ) {
11922 switch( i ) {
11923 case AEP_STR_UP:
11924 p.mod_str_bonus( +4 );
11925 break;
11926 case AEP_DEX_UP:
11927 p.mod_dex_bonus( +4 );
11928 break;
11929 case AEP_PER_UP:
11930 p.mod_per_bonus( +4 );
11931 break;
11932 case AEP_INT_UP:
11933 p.mod_int_bonus( +4 );
11934 break;
11935 case AEP_ALL_UP:
11936 p.mod_str_bonus( +2 );
11937 p.mod_dex_bonus( +2 );
11938 p.mod_per_bonus( +2 );
11939 p.mod_int_bonus( +2 );
11940 break;
11941 case AEP_SPEED_UP:
11942 // Handled in player::current_speed()
11943 break;
11944
11945 case AEP_PBLUE:
11946 if( p.get_rad() > 0 ) {
11947 p.mod_rad( -1 );
11948 }
11949 break;
11950
11951 case AEP_SMOKE:
11952 if( one_in( 10 ) ) {
11953 tripoint pt( p.posx() + rng( -1, 1 ),
11954 p.posy() + rng( -1, 1 ),
11955 p.posz() );
11956 m.add_field( pt, fd_smoke, rng( 1, 3 ) );
11957 }
11958 break;
11959
11960 case AEP_SNAKES:
11961 break; // Handled in player::hit()
11962
11963 case AEP_EXTINGUISH:
11964 for( const tripoint &dest : m.points_in_radius( p.pos(), 1 ) ) {
11965 m.mod_field_age( dest, fd_fire, -1_turns );
11966 }
11967 break;
11968
11969 case AEP_FUN:
11970 //Bonus fluctuates, wavering between 0 and 30-ish - usually around 12
11971 p.add_morale( MORALE_FEELING_GOOD, rng( 1, 2 ) * rng( 2, 3 ), 0, 3_turns, 0_turns, false );
11972 break;
11973
11974 case AEP_HUNGER:
11975 if( one_in( 100 ) ) {
11976 p.mod_stored_kcal( -10 );
11977 }
11978 break;
11979
11980 case AEP_THIRST:
11981 if( one_in( 120 ) ) {
11982 p.mod_thirst( 1 );
11983 }
11984 break;
11985
11986 case AEP_EVIL:
11987 if( one_in( 150 ) ) { // Once every 15 minutes, on average
11988 p.add_effect( effect_evil, 30_minutes );
11989 if( it.is_armor() ) {
11990 if( !worn ) {
11991 add_msg( _( "You have an urge to wear the %s." ),
11992 it.tname() );
11993 }
11994 } else if( !wielded ) {
11995 add_msg( _( "You have an urge to wield the %s." ),
11996 it.tname() );
11997 }
11998 }
11999 break;
12000
12001 case AEP_SCHIZO:
12002 break; // Handled in player::suffer()
12003
12004 case AEP_RADIOACTIVE:
12005 if( one_in( 4 ) ) {
12006 p.irradiate( 1.0f );
12007 }
12008 break;
12009
12010 case AEP_STR_DOWN:
12011 p.mod_str_bonus( -3 );
12012 break;
12013
12014 case AEP_DEX_DOWN:
12015 p.mod_dex_bonus( -3 );
12016 break;
12017
12018 case AEP_PER_DOWN:
12019 p.mod_per_bonus( -3 );
12020 break;
12021
12022 case AEP_INT_DOWN:
12023 p.mod_int_bonus( -3 );
12024 break;
12025
12026 case AEP_ALL_DOWN:
12027 p.mod_str_bonus( -2 );
12028 p.mod_dex_bonus( -2 );
12029 p.mod_per_bonus( -2 );
12030 p.mod_int_bonus( -2 );
12031 break;
12032
12033 case AEP_SPEED_DOWN:
12034 break; // Handled in player::current_speed()
12035
12036 default:
12037 //Suppress warnings
12038 break;
12039 }
12040 }
12041 // Recalculate, as it might have changed (by mod_*_bonus above)
12042 p.str_cur = p.get_str();
12043 p.int_cur = p.get_int();
12044 p.dex_cur = p.get_dex();
12045 p.per_cur = p.get_per();
12046}
@ ARTC_PORTAL
Definition: artifact.h:69
@ ARTC_FATIGUE
Definition: artifact.h:68
@ ARTC_NULL
Definition: artifact.h:63
@ ARTC_SOLAR
Definition: artifact.h:65
@ NUM_ARTCS
Definition: artifact.h:70
@ ARTC_HP
Definition: artifact.h:67
@ ARTC_TIME
Definition: artifact.h:64
@ ARTC_PAIN
Definition: artifact.h:66
virtual void mod_per_bonus(int nper)
Definition: character.cpp:4177
virtual void mod_dex_bonus(int ndex)
Definition: character.cpp:4172
int str_cur
Definition: character.h:304
void mod_rad(int mod)
Definition: character.cpp:7177
virtual int get_dex() const
Definition: character.cpp:4061
virtual void mod_stored_kcal(int nkcal)
Modifiers for need values exclusive to characters.
Definition: character.cpp:4292
bool is_worn(const item &thing) const
Definition: character.h:1142
virtual int get_int() const
Definition: character.cpp:4069
virtual void mod_fatigue(int nfatigue)
Definition: character.cpp:4423
virtual void mod_str_bonus(int nstr)
Definition: character.cpp:4167
int int_cur
Definition: character.h:306
int get_rad() const
Definition: character.cpp:7167
void add_morale(const morale_type &type, int bonus, int max_bonus=0, const time_duration &duration=1_hours, const time_duration &decay_start=30_minutes, bool capped=false, const itype *item_type=nullptr)
Definition: character.cpp:9082
virtual int get_per() const
Definition: character.cpp:4065
void mod_stamina(int mod)
Definition: character.cpp:7204
void hurtall(int dam, Creature *source, bool disturb=true)
Hurts all body parts for dam, no armor reduction.
Definition: character.cpp:8648
bool irradiate(float rads, bool bypass=false)
Handles mitigation and application of radiation.
Definition: suffer.cpp:1532
virtual void mod_int_bonus(int nint)
Definition: character.cpp:4182
virtual void mod_pain_noresist(int npain)
Definition: creature.cpp:1349
bool is_in_sunlight(const tripoint &p)
Returns true if p is outdoors and it is sunny.
Definition: game.cpp:5146
int ammo_remaining() const
Quantity of ammunition currently loaded in tool, gun or auxiliary gunmod.
Definition: item.cpp:7226
bool is_tool() const
Definition: item.cpp:6803
int ammo_capacity() const
Maximum quantity of ammunition loadable for tool, gun or auxiliary gunmod.
Definition: item.cpp:7253
int charges
Definition: item.h:2195
bool is_armor() const
Definition: item.cpp:6554
const itype * type
Definition: item.h:2156
bool add_field(const tripoint &p, const field_type_id &type_id, int intensity=INT_MAX, const time_duration &age=0_turns, bool hit_player=true)
Add field entry at point, or set intensity if present.
Definition: map.cpp:5391
time_duration mod_field_age(const tripoint &p, const field_type_id &type, const time_duration &offset)
Increment/decrement age of field entry at point.
Definition: map.cpp:5311
void remove_trap(const tripoint &p)
Definition: map.cpp:5256
art_effect_passive
Definition: enums.h:99
@ AEP_EXTINGUISH
Definition: enums.h:114
field_type_id fd_smoke
Definition: field_type.cpp:346
field_type_id fd_fatigue
Definition: field_type.cpp:354
static const efftype_id effect_evil("evil")
static const trap_str_id tr_portal("tr_portal")
const morale_type MORALE_FEELING_GOOD("morale_feeling_good")
cata::value_ptr< islot_artifact > artifact
Definition: itype.h:864

References _, Creature::add_effect(), map::add_field(), Character::add_morale(), add_msg(), AEP_ALL_DOWN, AEP_ALL_UP, AEP_DEX_DOWN, AEP_DEX_UP, AEP_EVIL, AEP_EXTINGUISH, AEP_FUN, AEP_HUNGER, AEP_INT_DOWN, AEP_INT_UP, AEP_PBLUE, AEP_PER_DOWN, AEP_PER_UP, AEP_RADIOACTIVE, AEP_SCHIZO, AEP_SMOKE, AEP_SNAKES, AEP_SPEED_DOWN, AEP_SPEED_UP, AEP_STR_DOWN, AEP_STR_UP, AEP_THIRST, item::ammo_capacity(), item::ammo_remaining(), ARTC_FATIGUE, ARTC_HP, ARTC_NULL, ARTC_PAIN, ARTC_PORTAL, ARTC_SOLAR, ARTC_TIME, itype::artifact, item::charges, check_art_charge_req(), Character::dex_cur, effect_evil, fd_fatigue, fd_fire, fd_smoke, Character::get_dex(), Character::get_int(), Character::get_per(), Character::get_rad(), Character::get_str(), Character::hurtall(), Character::int_cur, Character::irradiate(), item::is_armor(), is_in_sunlight(), item::is_tool(), Character::is_worn(), trap::loadid, m, m_bad, m_good, Character::mod_dex_bonus(), Character::mod_fatigue(), map::mod_field_age(), Character::mod_int_bonus(), Creature::mod_pain_noresist(), Character::mod_per_bonus(), Character::mod_rad(), Character::mod_stamina(), Character::mod_stored_kcal(), Character::mod_str_bonus(), Character::mod_thirst(), MORALE_FEELING_GOOD, NUM_ARTCS, calendar::once_every(), one_in(), Character::per_cur, map::points_in_radius(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), map::remove_field(), map::remove_trap(), rng(), Character::str_cur, item::tname(), map::tr_at(), tr_portal, item::type, u, and Character::weapon.

◆ process_voluntary_act_interrupt()

void game::process_voluntary_act_interrupt ( )
private

Definition at line 1701 of file game.cpp.

1702{
1703 if( u.has_effect( effect_sleep ) ) {
1704 // Can't interrupt
1705 return;
1706 }
1707
1708 bool has_activity = u.activity && u.activity.moves_left > 0;
1709 bool is_travelling = u.has_destination() && !u.omt_path.empty();
1710
1711 if( !has_activity && !is_travelling ) {
1712 // Nohing to interrupt
1713 return;
1714 }
1715
1716 // Key poll may be quite expensive, so limit it to 10 times per second.
1717 static auto last_poll = std::chrono::steady_clock::now();
1718 auto now = std::chrono::steady_clock::now();
1719 int64_t difference = std::chrono::duration_cast<std::chrono::milliseconds>
1720 ( now - last_poll ).count();
1721
1722 if( difference > 100 ) {
1724 last_poll = now;
1725 }
1726
1727 // If player is performing a task and a monster is dangerously close, warn them
1728 // regardless of previous safemode warnings
1729 if( has_activity && !u.has_activity( activity_id( "ACT_AIM" ) ) &&
1731 Creature *hostile_critter = is_hostile_very_close();
1732 if( hostile_critter != nullptr ) {
1734 string_format( _( "The %s is dangerously close!" ),
1735 hostile_critter->get_name() ) );
1736 }
1737 }
1738}
bool has_activity(const activity_id &type) const
Check if player currently has a given activity.
Definition: character.cpp:9213
virtual std::string get_name() const =0
void handle_key_blocking_activity()
Definition: game.cpp:2055
int moves_left
The number of moves remaining in this activity before it is complete.

References _, Character::activity, cancel_activity_or_ignore_query(), effect_sleep, Creature::get_name(), handle_key_blocking_activity(), Character::has_activity(), Character::has_destination(), Creature::has_effect(), hostile_spotted_near, player_activity::is_distraction_ignored(), is_hostile_very_close(), player_activity::moves_left, Character::omt_path, string_format(), and u.

Referenced by do_turn().

◆ prompt_dangerous_tile()

bool game::prompt_dangerous_tile ( const tripoint dest_loc) const

Definition at line 9243 of file game.cpp.

9244{
9245 std::vector<std::string> harmful_stuff = get_dangerous_tile( dest_loc );
9246
9247 if( !harmful_stuff.empty() &&
9248 !query_yn( _( "Really step into %s?" ), enumerate_as_string( harmful_stuff ) ) ) {
9249 return false;
9250 }
9251 if( !harmful_stuff.empty() && u.is_mounted() &&
9252 m.tr_at( dest_loc ).loadid == tr_ledge ) {
9253 add_msg( m_warning, _( "Your %s refuses to move over that ledge!" ),
9254 u.mounted_creature->get_name() );
9255 return false;
9256 }
9257 return true;
9258}

References _, add_msg(), enumerate_as_string(), get_dangerous_tile(), Character::is_mounted(), trap::loadid, m, m_warning, Character::mounted_creature, query_yn(), map::tr_at(), tr_ledge, and u.

Referenced by npc_menu(), and walk_move().

◆ quickload()

void game::quickload ( )
private

Definition at line 11811 of file game.cpp.

11812{
11813 const WORLDPTR active_world = world_generator->active_world;
11814 if( active_world == nullptr ) {
11815 return;
11816 }
11817
11818 if( active_world->save_exists( save_t::from_player_name( u.name ) ) ) {
11819 if( moves_since_last_save != 0 ) { // See if we need to reload anything
11820 MAPBUFFER.reset();
11822 try {
11823 setup();
11824 } catch( const std::exception &err ) {
11825 debugmsg( "Error: %s", err.what() );
11826 }
11828 }
11829 } else {
11830 popup_getkey( _( "No saves for %s yet." ), u.name );
11831 }
11832}
bool load(const std::string &world)
Attempt to load first valid save (if any) in world.
Definition: game.cpp:2820
void setup()
Definition: game.cpp:558
static save_t from_player_name(const std::string &name)
int popup_getkey(const char *const mes, Args &&... args)
Definition: output.h:500
bool save_exists(const save_t &name) const

References _, overmapbuffer::clear(), debugmsg, save_t::from_player_name(), load(), MAPBUFFER, moves_since_last_save, Character::name, overmap_buffer, popup_getkey(), mapbuffer::reset(), WORLD::save_exists(), setup(), u, and world_generator.

Referenced by handle_action().

◆ quicksave()

void game::quicksave ( )

Definition at line 11789 of file game.cpp.

11790{
11791 //Don't autosave if the player hasn't done anything since the last autosave/quicksave,
11792 if( !moves_since_last_save ) {
11793 return;
11794 }
11795 add_msg( m_info, _( "Saving game, this may take a while" ) );
11796
11798 popup.message( "%s", _( "Saving game, this may take a while" ) );
11801
11802 time_t now = time( nullptr ); //timestamp for start of saving procedure
11803
11804 //perform save
11805 save();
11806 //Now reset counters for autosaving, so we don't immediately autosave after a quicksave or autosave.
11808 last_save_timestamp = now;
11809}

References _, add_msg(), last_save_timestamp, m_info, moves_since_last_save, popup(), ui_manager::redraw(), refresh_display(), and save().

Referenced by autosave(), and handle_action().

◆ reenter_fullscreen()

void game::reenter_fullscreen ( )

Definition at line 546 of file game.cpp.

547{
548 if( was_fullscreen ) {
549 if( !fullscreen ) {
551 }
552 }
553}

References fullscreen, toggle_fullscreen(), and was_fullscreen.

Referenced by list_items_monsters(), and look_around().

◆ reload()

void game::reload ( item_location loc,
bool  prompt = false,
bool  empty = true 
)

Definition at line 8833 of file game.cpp.

8834{
8836 item *it = loc.get_item();
8837
8838 // bows etc. do not need to reload. select favorite ammo for them instead
8839 if( it->has_flag( "RELOAD_AND_SHOOT" ) ) {
8841 return;
8842 }
8843
8844 switch( u.rate_action_reload( *it ) ) {
8845 case hint_rating::iffy:
8846 if( ( it->is_ammo_container() || it->is_magazine() ) && it->ammo_remaining() > 0 &&
8847 it->ammo_remaining() == it->ammo_capacity() ) {
8848 add_msg( m_info, _( "The %s is already fully loaded!" ), it->tname() );
8849 return;
8850 }
8851 if( it->is_ammo_belt() ) {
8852 const auto &linkage = it->type->magazine->linkage;
8853 if( linkage && !u.has_charges( *linkage, 1 ) ) {
8854 add_msg( m_info, _( "You need at least one %s to reload the %s!" ),
8855 item::nname( *linkage, 1 ), it->tname() );
8856 return;
8857 }
8858 }
8859 if( it->is_watertight_container() && it->is_container_full() ) {
8860 add_msg( m_info, _( "The %s is already full!" ), it->tname() );
8861 return;
8862 }
8863
8864 // intentional fall-through
8865
8866 case hint_rating::cant:
8867 add_msg( m_info, _( "You can't reload a %s!" ), it->tname() );
8868 return;
8869
8870 case hint_rating::good:
8871 break;
8872 }
8873
8874 bool use_loc = true;
8875 if( !it->has_flag( "ALLOWS_REMOTE_USE" ) ) {
8876 it = loc.obtain( u ).get_item();
8877 use_loc = false;
8878 }
8879
8880 // for holsters and ammo pouches try to reload any contained item
8881 if( it->type->can_use( "holster" ) && !it->contents.empty() ) {
8882 it = &it->contents.front();
8883 }
8884
8885 // for bandoliers we currently defer to iuse_actor methods
8886 if( it->is_bandolier() ) {
8887 auto ptr = dynamic_cast<const bandolier_actor *>
8888 ( it->type->get_use( "bandolier" )->get_actor_ptr() );
8889 ptr->reload( u, *it );
8890 return;
8891 }
8892
8894
8895 if( opt.ammo.get_item() == nullptr ) {
8896 return;
8897 }
8898
8899 if( opt ) {
8900 int moves = opt.moves();
8901 if( it->get_var( "dirt", 0 ) > 7800 ) {
8902 add_msg( m_warning, _( "You struggle to reload the fouled %s." ), it->tname() );
8903 moves += 2500;
8904 }
8905
8906 u.assign_activity( activity_id( "ACT_RELOAD" ), moves, opt.qty() );
8907 if( use_loc ) {
8908 u.activity.targets.emplace_back( loc );
8909 } else {
8910 u.activity.targets.emplace_back( u, const_cast<item *>( opt.target ) );
8911 }
8912 u.activity.targets.push_back( std::move( opt.ammo ) );
8913 }
8914}
bool has_charges(const itype_id &it, int quantity, const std::function< bool(const item &)> &filter=return_true< item >) const
Definition: character.cpp:9589
Store ammo and later reload using it.
Definition: iuse_actor.h:885
int moves() const
Definition: item.cpp:7876
const item * target
Definition: item.h:482
int qty() const
Definition: item.h:485
item_location ammo
Definition: item.h:483
item & front()
this is an artifact of the previous code using front() everywhere for contents.
bool empty() const
item * get_item()
Gets the selected item or nullptr.
item_location obtain(Character &ch, int qty=-1)
Move an item from the location to the character inventory.
double get_var(const std::string &name, double default_value) const
Definition: item.cpp:1022
bool is_ammo_container() const
Definition: item.cpp:6512
bool is_watertight_container() const
Whether this is a container which can be used to store liquids.
Definition: item.cpp:6574
static std::string nname(const itype_id &id, unsigned int quantity=1)
Returns the translated item name for the item with given id.
Definition: item.cpp:9749
bool is_ammo_belt() const
Definition: item.cpp:6417
item_contents contents
Definition: item.h:2157
bool is_container_full(bool allow_bucket=false) const
Whether this item has no more free capacity for its current content.
Definition: item.cpp:6692
bool is_bandolier() const
Definition: item.cpp:6422
bool is_magazine() const
Definition: item.cpp:6407
item_location ammo_location
Definition: player.h:693
const void * ptr(const T *p)
\rst Converts p to const void* for pointer formatting.
static item::reload_option favorite_ammo_or_select(const player &u, const item &it, bool empty, bool prompt)
Definition: game.cpp:8814
@ prompt
Definition: pickup.h:30
const use_function * get_use(const std::string &iuse_name) const
Definition: itype.cpp:91
cata::value_ptr< islot_magazine > magazine
Definition: itype.h:859
bool can_use(const std::string &iuse_name) const
Definition: itype.cpp:86

References _, Character::activity, add_msg(), item::reload_option::ammo, item::ammo_capacity(), player::ammo_location, item::ammo_remaining(), Character::assign_activity(), itype::can_use(), cant, item::contents, item_contents::empty(), favorite_ammo_or_select(), item_contents::front(), use_function::get_actor_ptr(), item_location::get_item(), itype::get_use(), item::get_var(), good, Character::has_charges(), item::has_flag(), iffy, item::is_ammo_belt(), item::is_ammo_container(), item::is_bandolier(), item::is_container_full(), item::is_magazine(), item::is_watertight_container(), m_info, m_warning, itype::magazine, item_location::make_dirty(), avatar_action::move(), item::reload_option::moves(), item::nname(), item_location::obtain(), pickup::prompt, ranged::prompt_select_default_ammo_for(), ptr(), item::reload_option::qty(), player::rate_action_reload(), item::reload_option::target, player_activity::targets, item::tname(), item::type, and u.

Referenced by inventory_item_menu(), reload_item(), and reload_wielded().

◆ reload_item()

void game::reload_item ( )

Definition at line 8917 of file game.cpp.

8918{
8919 item_location item_loc = inv_map_splice( [&]( const item & it ) {
8920 return u.rate_action_reload( it ) == hint_rating::good;
8921 }, _( "Reload item" ), 1, _( "You have nothing to reload." ) );
8922
8923 if( !item_loc ) {
8924 add_msg( _( "Never mind." ) );
8925 return;
8926 }
8927
8928 reload( item_loc );
8929}
item_location inv_map_splice(item_filter filter, const std::string &title, int radius=0, const std::string &none_message="")
Custom-filtered menu for inventory and nearby items and those that within specified radius.

References _, add_msg(), good, inv_map_splice(), player::rate_action_reload(), reload(), and u.

Referenced by handle_action().

◆ reload_npcs()

void game::reload_npcs ( )

Unloads, then loads the NPCs.

Definition at line 958 of file game.cpp.

959{
960 // TODO: Make it not invoke the "on_unload" command for the NPCs that will be loaded anyway
961 // and not invoke "on_load" for those NPCs that avoided unloading this way.
962 unload_npcs();
963 load_npcs();
964}

References load_npcs(), and unload_npcs().

Referenced by load(), overmap_npc_move(), vertical_move(), and vertical_shift().

◆ reload_tileset()

void game::reload_tileset ( )

Definition at line 519 of file game.cpp.

520{
521#if defined(TILES)
522 try {
523 tilecontext->reinit();
524 tilecontext->load_tileset( get_option<std::string>( "TILES" ), false, true );
525 tilecontext->do_tile_loading_report();
526 } catch( const std::exception &err ) {
527 popup( _( "Loading the tileset failed: %s" ), err.what() );
528 }
529 g->reset_zoom();
530 g->mark_main_ui_adaptor_resize();
531#endif // TILES
532}

References _, g, and popup().

Referenced by handle_action().

◆ reload_weapon()

void game::reload_weapon ( bool  try_everything = true)

Definition at line 8941 of file game.cpp.

8942{
8943 // As a special streamlined activity, hitting reload repeatedly should:
8944 // Reload wielded gun
8945 // First reload a magazine if necessary.
8946 // Then load said magazine into gun.
8947 // Reload magazines that are compatible with the current gun.
8948 // Reload other guns in inventory.
8949 // Reload misc magazines in inventory.
8950 std::vector<item_location> reloadables = u.find_reloadables();
8951 std::sort( reloadables.begin(), reloadables.end(),
8952 [this]( const item_location & a, const item_location & b ) {
8953 const item *ap = a.get_item();
8954 const item *bp = b.get_item();
8955 // Current wielded weapon comes first.
8956 if( this->u.is_wielding( *bp ) ) {
8957 return false;
8958 }
8959 if( this->u.is_wielding( *ap ) ) {
8960 return true;
8961 }
8962 // Second sort by affiliation with wielded gun
8963 const std::set<itype_id> compatible_magazines = this->u.weapon.magazine_compatible();
8964 const bool mag_ap = compatible_magazines.count( ap->typeId() ) > 0;
8965 const bool mag_bp = compatible_magazines.count( bp->typeId() ) > 0;
8966 if( mag_ap != mag_bp ) {
8967 return mag_ap;
8968 }
8969 // Third sort by gun vs magazine,
8970 if( ap->is_gun() != bp->is_gun() ) {
8971 return ap->is_gun();
8972 }
8973 // Finally sort by speed to reload.
8974 return ( ap->get_reload_time() * ( ap->ammo_capacity() - ap->ammo_remaining() ) ) <
8975 ( bp->get_reload_time() * ( bp->ammo_capacity() - bp->ammo_remaining() ) );
8976 } );
8977 for( item_location &candidate : reloadables ) {
8978 std::vector<item::reload_option> ammo_list;
8979 u.list_ammo( *candidate.get_item(), ammo_list, false );
8980 if( !ammo_list.empty() ) {
8981 reload( candidate, false, false );
8982 return;
8983 }
8984 }
8985 // Just for testing, bail out here to avoid unwanted side effects.
8986 if( !try_everything ) {
8987 return;
8988 }
8989 // If we make it here and haven't found anything to reload, start looking elsewhere.
8990 vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
8991 turret_data turret;
8992 if( veh && ( turret = veh->turret_query( u.pos() ) ) && turret.can_reload() ) {
8993 item::reload_option opt = g->u.select_ammo( *turret.base(), true );
8994 if( opt ) {
8995 g->u.assign_activity( activity_id( "ACT_RELOAD" ), opt.moves(), opt.qty() );
8996 g->u.activity.targets.emplace_back( turret.base() );
8997 g->u.activity.targets.push_back( std::move( opt.ammo ) );
8998 }
8999 return;
9000 }
9001
9002 reload_item();
9003}
std::vector< item_location > find_reloadables()
Searches for weapons and magazines that can be reloaded.
Definition: character.cpp:2683
bool list_ammo(const item &base, std::vector< item::reload_option > &ammo_list, bool include_empty_mags=true, bool include_potential=false) const
Definition: player.cpp:2389
bool can_reload() const
Definition: turret.cpp:212
item_location base()
Get base item location.
Definition: turret.cpp:84
turret_data turret_query(vehicle_part &pt)
Get firing data for a turret.
Definition: turret.cpp:55
constexpr double a
Definition: magic.cpp:1030
constexpr double b
Definition: magic.cpp:1031

References a, b, Character::find_reloadables(), and u.

Referenced by handle_action().

◆ reload_wielded()

void game::reload_wielded ( bool  prompt = false)

Definition at line 8931 of file game.cpp.

8932{
8933 if( u.weapon.is_null() || !u.weapon.is_reloadable() ) {
8934 add_msg( _( "You aren't holding something you can reload." ) );
8935 return;
8936 }
8937 item_location item_loc = item_location( u, &u.weapon );
8938 reload( item_loc, prompt );
8939}
bool is_null() const
Definition: item.cpp:729
bool is_reloadable() const
Is it ever possible to reload this item? Only the base item is considered with any mods ignored.
Definition: item.cpp:9657

References _, add_msg(), item::is_null(), item::is_reloadable(), pickup::prompt, reload(), u, and Character::weapon.

Referenced by handle_action().

◆ remoteveh()

vehicle * game::remoteveh ( )

Returns the current remotely controlled vehicle.

Definition at line 2561 of file game.cpp.

2562{
2564 return remoteveh_cache;
2565 }
2567 std::stringstream remote_veh_string( u.get_value( "remote_controlling_vehicle" ) );
2568 if( remote_veh_string.str().empty() ||
2570 remoteveh_cache = nullptr;
2571 } else {
2572 tripoint vp;
2573 remote_veh_string >> vp.x >> vp.y >> vp.z;
2574 vehicle *veh = veh_pointer_or_null( m.veh_at( vp ) );
2575 if( veh && veh->fuel_left( itype_battery, true ) > 0 ) {
2576 remoteveh_cache = veh;
2577 } else {
2578 remoteveh_cache = nullptr;
2579 }
2580 }
2581 return remoteveh_cache;
2582}
vehicle * remoteveh_cache
Definition: game.h:1093
int fuel_left(const itype_id &ftype, bool recurse=false) const
Definition: vehicle.cpp:3182
static const bionic_id bio_remote("bio_remote")
static const itype_id itype_remotevehcontrol("remotevehcontrol")
static const itype_id itype_battery("battery")

References bio_remote, vehicle::fuel_left(), Creature::get_value(), Character::has_active_bionic(), Character::has_active_item(), itype_battery, itype_remotevehcontrol, m, remoteveh_cache, remoteveh_cache_time, calendar::turn, u, map::veh_at(), veh_pointer_or_null(), tripoint::x, tripoint::y, and tripoint::z.

Referenced by control_vehicle(), and handle_action().

◆ remove_npc_follower()

void game::remove_npc_follower ( const character_id id)

Remove follower id from follower set.

Definition at line 1964 of file game.cpp.

1965{
1966 follower_ids.erase( id );
1967 u.follower_ids.erase( id );
1968}

References follower_ids, player::follower_ids, and u.

Referenced by cleanup_dead().

◆ remove_zombie()

void game::remove_zombie ( const monster critter)

Definition at line 5025 of file game.cpp.

5026{
5027 critter_tracker->remove( critter );
5028}

References critter_tracker.

Referenced by despawn_monster(), disable_robot(), start_game(), and vertical_move().

◆ replace_stair_monsters()

void game::replace_stair_monsters ( )
private

Definition at line 11309 of file game.cpp.

11310{
11311 for( auto &elem : coming_to_stairs ) {
11312 elem.staircount = 0;
11313 const tripoint pnt( elem.pos().xy(), get_levz() );
11314 place_critter_around( make_shared_fast<monster>( elem ), pnt, 10 );
11315 }
11316
11317 coming_to_stairs.clear();
11318}
std::vector< monster > coming_to_stairs
Definition: game.h:1031

References coming_to_stairs, get_levz(), and place_critter_around().

◆ reset_item_list_state()

void game::reset_item_list_state ( const catacurses::window window,
int  height,
bool  bRadiusSort 
)
private

Definition at line 7415 of file game.cpp.

7416{
7417 const int width = getmaxx( window );
7418 for( int i = 1; i < TERMX; i++ ) {
7419 if( i < width ) {
7420 mvwputch( window, point( i, 0 ), c_light_gray, LINE_OXOX ); // -
7421 mvwputch( window, point( i, TERMY - height - 1 ), c_light_gray,
7422 LINE_OXOX ); // -
7423 }
7424
7425 if( i < TERMY - height ) {
7426 mvwputch( window, point( 0, i ), c_light_gray, LINE_XOXO ); // |
7427 mvwputch( window, point( width - 1, i ), c_light_gray, LINE_XOXO ); // |
7428 }
7429 }
7430
7431 mvwputch( window, point_zero, c_light_gray, LINE_OXXO ); // |^
7432 mvwputch( window, point( width - 1, 0 ), c_light_gray, LINE_OOXX ); // ^|
7433
7434 mvwputch( window, point( 0, TERMY - height - 1 ), c_light_gray,
7435 LINE_XXXO ); // |-
7436 mvwputch( window, point( width - 1, TERMY - height - 1 ), c_light_gray,
7437 LINE_XOXX ); // -|
7438
7439 mvwprintz( window, point( 2, 0 ), c_light_green, "<Tab> " );
7440 wprintz( window, c_white, _( "Items" ) );
7441
7442 std::string sSort;
7443 if( bRadiusSort ) {
7444 //~ Sort type: distance.
7445 sSort = _( "<s>ort: dist" );
7446 } else {
7447 //~ Sort type: category.
7448 sSort = _( "<s>ort: cat" );
7449 }
7450
7451 int letters = utf8_width( sSort );
7452
7453 shortcut_print( window, point( getmaxx( window ) - letters, 0 ), c_white, c_light_green, sSort );
7454
7455 std::vector<std::string> tokens;
7456 if( !sFilter.empty() ) {
7457 tokens.emplace_back( _( "<R>eset" ) );
7458 }
7459
7460 tokens.emplace_back( _( "<E>xamine" ) );
7461 tokens.emplace_back( _( "<C>ompare" ) );
7462 tokens.emplace_back( _( "<F>ilter" ) );
7463 tokens.emplace_back( _( "<+/->Priority" ) );
7464
7465 int gaps = tokens.size() + 1;
7466 letters = 0;
7467 int n = tokens.size();
7468 for( int i = 0; i < n; i++ ) {
7469 letters += utf8_width( tokens[i] ) - 2; //length ignores < >
7470 }
7471
7472 int usedwidth = letters;
7473 const int gap_spaces = ( width - usedwidth ) / gaps;
7474 usedwidth += gap_spaces * gaps;
7475 point pos( gap_spaces + ( width - usedwidth ) / 2, TERMY - height - 1 );
7476
7477 for( int i = 0; i < n; i++ ) {
7478 pos.x += shortcut_print( window, pos, c_white, c_light_green,
7479 tokens[i] ) + gap_spaces;
7480 }
7481}
#define LINE_OOXX
Definition: output.h:43
#define LINE_OXXO
Definition: output.h:42

References _, c_light_gray, c_light_green, c_white, catacurses::getmaxx(), LINE_OOXX, LINE_OXOX, LINE_OXXO, LINE_XOXO, LINE_XOXX, LINE_XXXO, mvwprintz(), mvwputch(), point_zero, sFilter, shortcut_print(), TERMX, TERMY, utf8_width(), wprintz(), and point::x.

Referenced by list_items().

◆ reset_light_level()

void game::reset_light_level ( )

Definition at line 3922 of file game.cpp.

3923{
3924 for( float &lev : latest_lightlevels ) {
3925 lev = -std::numeric_limits<float>::max();
3926 }
3927}

References latest_lightlevels.

Referenced by do_turn(), and game().

◆ reset_npc_dispositions()

void game::reset_npc_dispositions ( )
private

Definition at line 2997 of file game.cpp.

2998{
2999 for( auto elem : follower_ids ) {
3000 shared_ptr_fast<npc> npc_to_get = overmap_buffer.find_npc( elem );
3001 if( !npc_to_get ) {
3002 continue;
3003 }
3004 npc *npc_to_add = npc_to_get.get();
3005 npc_to_add->chatbin.missions.clear();
3006 npc_to_add->chatbin.missions_assigned.clear();
3007 npc_to_add->mission = NPC_MISSION_NULL;
3008 npc_to_add->chatbin.mission_selected = nullptr;
3009 npc_to_add->set_attitude( NPCATT_NULL );
3010 npc_to_add->op_of_u.anger = 0;
3011 npc_to_add->op_of_u.fear = 0;
3012 npc_to_add->op_of_u.trust = 0;
3013 npc_to_add->op_of_u.value = 0;
3014 npc_to_add->op_of_u.owed = 0;
3015 npc_to_add->set_fac( faction_id( "no_faction" ) );
3017 npc_to_add->global_omt_location(),
3018 npc_to_add->getID() ) );
3019
3020 }
3021
3022}
void set_attitude(npc_attitude new_attitude)
Definition: npc.cpp:3141
npc_chatbin chatbin
Definition: npc.h:1329
void add_new_mission(mission *miss)
See npc_chatbin::add_new_mission.
Definition: npc.cpp:2637
npc_opinion op_of_u
Definition: npc.h:1328
void set_fac(const faction_id &id)
Definition: npc.cpp:465
std::vector< mission * > missions_assigned
Mission that have been assigned by this NPC to a player character.
Definition: npc.h:752
mission * mission_selected
The mission (if any) that we talk about right now.
Definition: npc.h:757
std::vector< mission * > missions
Missions that the NPC can give out.
Definition: npc.h:748
int value
Definition: npc.h:242
int trust
Definition: npc.h:240
int owed
Definition: npc.h:244
int fear
Definition: npc.h:241
int anger
Definition: npc.h:243

References npc::add_new_mission(), npc_opinion::anger, npc::chatbin, npc_opinion::fear, overmapbuffer::find_npc(), follower_ids, Character::getID(), Character::global_omt_location(), npc::mission, npc_chatbin::mission_selected, npc_chatbin::missions, npc_chatbin::missions_assigned, NPC_MISSION_NULL, NPCATT_NULL, npc::op_of_u, ORIGIN_ANY_NPC, overmap_buffer, npc_opinion::owed, mission::reserve_random(), npc::set_attitude(), npc::set_fac(), npc_opinion::trust, and npc_opinion::value.

Referenced by cleanup_at_end().

◆ reset_zoom()

void game::reset_zoom ( )

Definition at line 7330 of file game.cpp.

7331{
7332#if defined(TILES)
7334 rescale_tileset( tileset_zoom );
7335#endif // TILES
7336}

References DEFAULT_TILESET_ZOOM, and tileset_zoom.

◆ revive_corpse()

bool game::revive_corpse ( const tripoint p,
item it 
)

Revives a corpse at given location.

The monster type and some of its properties are deducted from the corpse. If reviving succeeds, the location is guaranteed to have a new monster there (see critter_at).

Parameters
pThe place where to put the revived monster.
itThe corpse item, it must be a valid corpse (see item::is_corpse).
Returns
Whether the corpse has actually been redivided. Reviving may fail for many reasons, including no space to put the monster, corpse being to much damaged etc. If the monster was revived, the caller should remove the corpse item. If reviving failed, the item is unchanged, as is the environment (no new monsters).

Definition at line 5156 of file game.cpp.

5157{
5158 if( !it.is_corpse() ) {
5159 debugmsg( "Tried to revive a non-corpse." );
5160 return false;
5161 }
5162 shared_ptr_fast<monster> newmon_ptr = make_shared_fast<monster>
5163 ( it.get_mtype()->id );
5164 monster &critter = *newmon_ptr;
5165 critter.init_from_item( it );
5166 if( critter.get_hp() < 1 ) {
5167 // Failed reanimation due to corpse being too burned
5168 return false;
5169 }
5170 if( it.has_flag( "FIELD_DRESS" ) || it.has_flag( "FIELD_DRESS_FAILED" ) ||
5171 it.has_flag( "QUARTERED" ) ) {
5172 // Failed reanimation due to corpse being butchered
5173 return false;
5174 }
5175
5176 critter.no_extra_death_drops = true;
5177 critter.add_effect( effect_downed, 5_turns, num_bp );
5178 for( const item &component : it.components ) {
5179 critter.corpse_components.push_back( component );
5180 }
5181
5182 if( it.get_var( "zlave" ) == "zlave" ) {
5183 critter.add_effect( effect_pacified, 1_turns, num_bp );
5184 critter.add_effect( effect_pet, 1_turns, num_bp );
5185 }
5186
5187 if( it.get_var( "no_ammo" ) == "no_ammo" ) {
5188 for( auto &ammo : critter.ammo ) {
5189 ammo.second = 0;
5190 }
5191 }
5192
5193 return place_critter_at( newmon_ptr, p );
5194}
monster * place_critter_at(const mtype_id &id, const tripoint &p)
Adds critters to the reality bubble, creating them if necessary.
Definition: game.cpp:4953
const mtype * get_mtype() const
Definition: item.cpp:6475
std::list< item > components
Definition: item.h:2158
bool is_corpse() const
Whether this is a corpse item.
Definition: item.cpp:6470
int get_hp(const bodypart_id &) const override
Definition: monster.cpp:2894
bool no_extra_death_drops
Definition: monster.h:480
std::vector< item > corpse_components
Definition: monster.h:457
void init_from_item(const item &itm)
Initialize values like speed / hp from data of an item.
Definition: monster.cpp:2758
static const efftype_id effect_downed("downed")
static const efftype_id effect_pacified("pacified")

References monster::add_effect(), monster::ammo, item::components, monster::corpse_components, debugmsg, effect_downed, effect_pacified, effect_pet, monster::get_hp(), item::get_mtype(), item::get_var(), item::has_flag(), mtype::id, monster::init_from_item(), item::is_corpse(), monster::no_extra_death_drops, num_bp, and place_critter_at().

◆ save()

bool game::save ( )

Returns false if saving failed.

Definition at line 3098 of file game.cpp.

3099{
3100 try {
3101 if( !save_player_data() ||
3103 !save_artifacts() ||
3104 !save_maps() ||
3105 !get_auto_pickup().save_character() ||
3107 !get_safemode().save_character() ||
3108 !write_to_file( get_world_base_save_path() + "/uistate.json", [&]( std::ostream & fout ) {
3109 JsonOut jsout( fout );
3110 uistate.serialize( jsout );
3111 }, _( "uistate data" ) ) ) {
3112 return false;
3113 } else {
3114 world_generator->active_world->add_save( save_t::from_player_name( u.name ) );
3115 return true;
3116 }
3117 } catch( std::ios::failure &err ) {
3118 popup( _( "Failed to save game data" ) );
3119 return false;
3120 }
3121}
void write_to_file(const std::string &path, const std::function< void(std::ostream &)> &writer)
Definition: json.h:580
bool save_player_data()
Definition: game.cpp:3052
void serialize(JsonOut &json) const
@ failure
Definition: behavior.h:20

References _, behavior::failure, save_t::from_player_name(), get_auto_notes_settings(), get_auto_pickup(), get_safemode(), get_world_base_save_path(), Character::name, popup(), save(), save_artifacts(), save_factions_missions_npcs(), save_maps(), save_player_data(), uistatedata::serialize(), u, uistate, world_generator, and write_to_file().

Referenced by handle_action(), quicksave(), and save().

◆ save_artifacts()

bool game::save_artifacts ( )
private

Definition at line 3033 of file game.cpp.

3034{
3035 std::string artfilename = get_world_base_save_path() + "/" + SAVE_ARTIFACTS;
3036 return ::save_artifacts( artfilename );
3037}
bool save_artifacts(const std::string &path)
Definition: artifact.cpp:1277

References get_world_base_save_path(), SAVE_ARTIFACTS(), and save_artifacts().

Referenced by cleanup_at_end(), and save().

◆ save_cyborg()

void game::save_cyborg ( item cyborg,
const tripoint couch_pos,
player installer 
)

Turns Broken Cyborg monster into Cyborg NPC via surgery.

Definition at line 5196 of file game.cpp.

5197{
5198 int assist_bonus = installer.get_effect_int( effect_assisted );
5199
5200 float adjusted_skill = installer.bionics_adjusted_skill( skill_firstaid,
5203 -1 );
5204
5205 int damage = cyborg->damage();
5206 int dmg_lvl = cyborg->damage_level( 4 );
5207 int difficulty = 12;
5208
5209 if( damage != 0 ) {
5210
5211 popup( _( "WARNING: Patient's body is damaged. Difficulty of the procedure is increased by %s." ),
5212 dmg_lvl );
5213
5214 // Damage of the cyborg increases difficulty
5215 difficulty += dmg_lvl;
5216 }
5217
5218 int chance_of_success = bionic_manip_cos( adjusted_skill + assist_bonus, difficulty );
5219 int success = chance_of_success - rng( 1, 100 );
5220
5221 if( !g->u.query_yn(
5222 _( "WARNING: %i percent chance of SEVERE damage to all body parts! Continue anyway?" ),
5223 100 - static_cast<int>( chance_of_success ) ) ) {
5224 return;
5225 }
5226
5227 if( success > 0 ) {
5228 add_msg( m_good, _( "Successfully removed Personality override." ) );
5229 add_msg( m_bad, _( "Autodoc immediately destroys the CBM upon removal." ) );
5230
5231 m.i_rem( couch_pos, cyborg );
5232
5233 const string_id<npc_template> npc_cyborg( "cyborg_rescued" );
5234 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
5235 tmp->normalize();
5236 tmp->load_npc_template( npc_cyborg );
5237 tmp->spawn_at_precise( { get_levx(), get_levy() }, couch_pos );
5239 tmp->hurtall( dmg_lvl * 10, nullptr );
5240 tmp->add_effect( effect_downed, rng( 1_turns, 4_turns ), num_bp, 0, true );
5241 load_npcs();
5242
5243 } else {
5244 const int failure_level = static_cast<int>( std::sqrt( std::abs( success ) * 4.0 * difficulty /
5245 adjusted_skill ) );
5246 const int fail_type = std::min( 5, failure_level );
5247 switch( fail_type ) {
5248 case 1:
5249 case 2:
5250 add_msg( m_info, _( "The removal fails." ) );
5251 add_msg( m_bad, _( "The body is damaged." ) );
5252 cyborg->set_damage( damage + 1000 );
5253 break;
5254 case 3:
5255 case 4:
5256 add_msg( m_info, _( "The removal fails badly." ) );
5257 add_msg( m_bad, _( "The body is badly damaged!" ) );
5258 cyborg->set_damage( damage + 2000 );
5259 break;
5260 case 5:
5261 add_msg( m_info, _( "The removal is a catastrophe." ) );
5262 add_msg( m_bad, _( "The body is destroyed!" ) );
5263 m.i_rem( couch_pos, cyborg );
5264 break;
5265 default:
5266 break;
5267 }
5268
5269 }
5270
5271}
int bionic_manip_cos(float adjusted_skill, int bionic_difficulty)
Definition: bionics.cpp:1888
float bionics_adjusted_skill(const skill_id &most_important_skill, const skill_id &important_skill, const skill_id &least_important_skill, int skill_level=-1)
Calculate skill for (un)installing bionics.
Definition: bionics.cpp:1845
item & set_damage(int qty)
Filter setting damage constrained by min_damage and max_damage.
Definition: item.cpp:711
int damage_level(int max) const
Scale item damage to the given number of levels.
Definition: item.cpp:698
int damage() const
How much damage has the item sustained?
Definition: item.cpp:693
map_stack::iterator i_rem(const tripoint &p, map_stack::const_iterator it)
Definition: map.cpp:4081
static const skill_id skill_computer("computer")
static const efftype_id effect_assisted("assisted")
static const skill_id skill_electronics("electronics")
@ success
Definition: behavior.h:20

References _, add_msg(), bionic_manip_cos(), Character::bionics_adjusted_skill(), item::damage(), item::damage_level(), effect_assisted, effect_downed, g, Creature::get_effect_int(), get_levx(), get_levy(), map::i_rem(), overmapbuffer::insert_npc(), load_npcs(), m, m_bad, m_good, m_info, num_bp, overmap_buffer, popup(), rng(), item::set_damage(), skill_computer, skill_electronics, skill_firstaid, and behavior::success.

◆ save_factions_missions_npcs()

bool game::save_factions_missions_npcs ( )
private

Definition at line 3025 of file game.cpp.

3026{
3027 std::string masterfile = get_world_base_save_path() + "/" + SAVE_MASTER;
3028 return write_to_file( masterfile, [&]( std::ostream & fout ) {
3029 serialize_master( fout );
3030 }, _( "factions data" ) );
3031}
void serialize_master(std::ostream &fout)
Definition: savegame.cpp:1257

References _, get_world_base_save_path(), SAVE_MASTER(), serialize_master(), and write_to_file().

Referenced by cleanup_at_end(), and save().

◆ save_maps()

bool game::save_maps ( )
private

Definition at line 3039 of file game.cpp.

3040{
3041 try {
3042 m.save();
3043 overmap_buffer.save(); // can throw
3044 MAPBUFFER.save(); // can throw
3045 return true;
3046 } catch( const std::exception &err ) {
3047 popup( _( "Failed to save the maps: %s" ), err.what() );
3048 return false;
3049 }
3050}
void save(bool delete_after_save=false)
Store all submaps in this instance into savefiles.
Definition: mapbuffer.cpp:103

References _, m, MAPBUFFER, overmap_buffer, popup(), map::save(), overmapbuffer::save(), and mapbuffer::save().

Referenced by cleanup_at_end(), and save().

◆ save_player_data()

bool game::save_player_data ( )
private

Definition at line 3052 of file game.cpp.

3053{
3054 const std::string playerfile = get_player_base_save_path();
3055
3056 const bool saved_data = write_to_file( playerfile + SAVE_EXTENSION, [&]( std::ostream & fout ) {
3057 serialize( fout );
3058 }, _( "player data" ) );
3059 const bool saved_map_memory = u.save_map_memory();
3060 const bool saved_log = write_to_file( playerfile + SAVE_EXTENSION_LOG, [&](
3061 std::ostream & fout ) {
3062 fout << memorial().dump();
3063 }, _( "player memorial" ) );
3064#if defined(__ANDROID__)
3065 const bool saved_shortcuts = write_to_file( playerfile + SAVE_EXTENSION_SHORTCUTS, [&](
3066 std::ostream & fout ) {
3067 save_shortcuts( fout );
3068 }, _( "quick shortcuts" ) );
3069#endif
3070
3071 return saved_data && saved_map_memory && saved_log
3072#if defined(__ANDROID__)
3073 && saved_shortcuts
3074#endif
3075 ;
3076}
bool save_map_memory()
Definition: avatar.cpp:127
std::string get_player_base_save_path() const
Base path for saving player data.
Definition: game.cpp:12526
void serialize(std::ostream &fout)
Saving and loading functions.
Definition: savegame.cpp:69
std::string dump() const
Concatenates all of the memorial log entries, delimiting them with newlines, and returns the resultin...

References _, memorial_logger::dump(), get_player_base_save_path(), memorial(), SAVE_EXTENSION(), SAVE_EXTENSION_LOG(), SAVE_EXTENSION_SHORTCUTS(), avatar::save_map_memory(), serialize(), u, and write_to_file().

Referenced by save().

◆ serialize()

void game::serialize ( std::ostream &  fout)

Saving and loading functions.

Definition at line 69 of file savegame.cpp.

70{
71 /*
72 * Format version 12: Fully json, save the header. Weather and memorial exist elsewhere.
73 * To prevent (or encourage) confusion, there is no version 8. (cata 0.8 uses v7)
74 */
75 // Header
76 fout << "# version " << savegame_version << std::endl;
77
78 JsonOut json( fout, true ); // pretty-print
79
80 json.start_object();
81 // basic game state information.
82 json.member( "turn", calendar::turn );
84 json.member( "calendar_start", calendar_config._start_of_cataclysm );
85 json.member( "game_start", calendar_config._start_of_game );
86 json.member( "initial_season", static_cast<int>( calendar_config._initial_season ) );
87 json.member( "auto_travel_mode", auto_travel_mode );
88 json.member( "run_mode", static_cast<int>( safe_mode ) );
89 json.member( "mostseen", mostseen );
90 // current map coordinates
91 tripoint pos_sm = m.get_abs_sub();
92 const point pos_om = sm_to_om_remain( pos_sm.x, pos_sm.y );
93 json.member( "levx", pos_sm.x );
94 json.member( "levy", pos_sm.y );
95 json.member( "levz", pos_sm.z );
96 json.member( "om_x", pos_om.x );
97 json.member( "om_y", pos_om.y );
98
99 json.member( "grscent", scent.serialize() );
100 json.member( "typescent", scent.serialize( true ) );
101
102 // Then each monster
103 json.member( "active_monsters", *critter_tracker );
104 json.member( "stair_monsters", coming_to_stairs );
105
106 // save stats.
107 json.member( "kill_tracker", *kill_tracker_ptr );
108 json.member( "stats_tracker", *stats_tracker_ptr );
109 json.member( "achievements_tracker", *achievements_tracker_ptr );
110
111 json.member( "token_provider", *token_provider_ptr );
112
113 json.member( "player", u );
114 Messages::serialize( json );
115
116 json.end_object();
117}
A class that keeps time data other than current time.
Definition: calendar.h:530
season_type _initial_season
Definition: calendar.h:534
time_point _start_of_game
Definition: calendar.h:533
time_point _start_of_cataclysm
Definition: calendar.h:532
pimpl< drop_token_provider > token_provider_ptr
Definition: game.h:1023
std::string serialize(bool is_type=false) const
Definition: savegame.cpp:119
point sm_to_om_remain(int &x, int &y)
void serialize(JsonOut &json)
Definition: messages.cpp:321
calendar_config config
const int savegame_version
Definition: savegame.cpp:57

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, achievements_tracker_ptr, auto_travel_mode, coming_to_stairs, calendar::config, critter_tracker, JsonOut::end_object(), map::get_abs_sub(), kill_tracker_ptr, m, JsonOut::member(), mostseen, safe_mode, savegame_version, scent, scent_map::serialize(), Messages::serialize(), sm_to_om_remain(), JsonOut::start_object(), stats_tracker_ptr, token_provider_ptr, calendar::turn, u, point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

Referenced by save_player_data().

◆ serialize_master()

void game::serialize_master ( std::ostream &  fout)
private

Definition at line 1257 of file savegame.cpp.

1258{
1259 fout << "# version " << savegame_version << std::endl;
1260 try {
1261 JsonOut json( fout, true ); // pretty-print
1262 json.start_object();
1263
1264 json.member( "next_mission_id", next_mission_id );
1265 json.member( "next_npc_id", next_npc_id );
1266
1267 json.member( "active_missions" );
1268 mission::serialize_all( json );
1269
1270 json.member( "factions", *faction_manager_ptr );
1271 json.member( "seed", seed );
1272
1273 json.member( "weather" );
1274 json.start_object();
1275 json.member( "lightning", get_weather().lightning_active );
1276 json.end_object();
1277
1278 json.end_object();
1279 } catch( const JsonError &e ) {
1280 debugmsg( "error saving to %s: %s", SAVE_MASTER, e.c_str() );
1281 }
1282}
Definition: json.h:51
const char * c_str() const noexcept
Definition: json.h:54
static void serialize_all(JsonOut &json)
Definition: savegame.cpp:1248

References JsonError::c_str(), debugmsg, JsonOut::end_object(), faction_manager_ptr, get_weather, JsonOut::member(), next_mission_id, next_npc_id, SAVE_MASTER(), savegame_version, seed, mission::serialize_all(), and JsonOut::start_object().

Referenced by save_factions_missions_npcs().

◆ set_critter_died()

void game::set_critter_died ( )

If invoked, dead will be cleaned this turn.

Definition at line 1872 of file game.cpp.

1873{
1874 critter_died = true;
1875}

References critter_died.

◆ set_driving_view_offset()

void game::set_driving_view_offset ( const point p)

Definition at line 1689 of file game.cpp.

1690{
1691 // remove the previous driving offset,
1692 // store the new offset and apply the new offset.
1699}

References driving_view_offset, u, player::view_offset, point::x, tripoint::x, point::y, and tripoint::y.

Referenced by calc_driving_offset(), and cleanup_at_end().

◆ set_npcs_dirty()

void game::set_npcs_dirty ( )

If invoked, NPCs will be reloaded before next turn.

Definition at line 1867 of file game.cpp.

1868{
1869 npcs_dirty = true;
1870}

References npcs_dirty.

◆ set_safe_mode()

void game::set_safe_mode ( safe_mode_type  mode)

Definition at line 9171 of file game.cpp.

9172{
9173 safe_mode = mode;
9175}

References safe_mode, and safe_mode_warning_logged.

Referenced by handle_action(), and mon_info_update().

◆ set_zoom()

void game::set_zoom ( int  level)

Definition at line 7338 of file game.cpp.

7339{
7340#if defined(TILES)
7341 if( tileset_zoom != level ) {
7342 tileset_zoom = level;
7343 rescale_tileset( tileset_zoom );
7344 }
7345#else
7346 static_cast<void>( level );
7347#endif // TILES
7348}

References tileset_zoom.

Referenced by look_around().

◆ setremoteveh()

void game::setremoteveh ( vehicle veh)

Sets the current remotely controlled vehicle.

Definition at line 2584 of file game.cpp.

2585{
2587 remoteveh_cache = veh;
2588 if( veh != nullptr && !u.has_active_bionic( bio_remote ) &&
2590 debugmsg( "Tried to set remote vehicle without bio_remote or remotevehcontrol" );
2591 veh = nullptr;
2592 }
2593
2594 if( veh == nullptr ) {
2595 u.remove_value( "remote_controlling_vehicle" );
2596 return;
2597 }
2598
2599 std::stringstream remote_veh_string;
2600 const tripoint vehpos = veh->global_pos3();
2601 remote_veh_string << vehpos.x << ' ' << vehpos.y << ' ' << vehpos.z;
2602 u.set_value( "remote_controlling_vehicle", remote_veh_string.str() );
2603}
void remove_value(const std::string &key)
Definition: creature.cpp:1333

References bio_remote, debugmsg, vehicle::global_pos3(), Character::has_active_bionic(), Character::has_active_item(), itype_remotevehcontrol, remoteveh_cache, remoteveh_cache_time, Creature::remove_value(), Creature::set_value(), calendar::turn, u, tripoint::x, tripoint::y, and tripoint::z.

◆ setup()

void game::setup ( )

Definition at line 558 of file game.cpp.

559{
560 loading_ui ui( true );
561 {
564 popup.message( "%s", _( "Please wait while the world data loads…\nLoading core data" ) );
567
569 }
570
572
573 if( get_option<bool>( "ELEVATED_BRIDGES" ) && !get_option<bool>( "ZLEVELS" ) ) {
574 debugmsg( "\"Elevated bridges\" mod requires z-levels to be ENABLED to work properly!" );
575 }
576
577 m = map( get_option<bool>( "ZLEVELS" ) );
578
580 next_mission_id = 1;
581 new_game = true;
582 uquit = QUIT_NO; // We haven't quit the game
583 bVMonsterLookFire = true;
584
585 // invalidate calendar caches in case we were previously playing
586 // a different world
587 calendar::set_eternal_season( ::get_option<bool>( "ETERNAL_SEASON" ) );
588 calendar::set_season_length( ::get_option<int>( "SEASON_LENGTH" ) );
589
592
593 turnssincelastmon = 0; //Auto safe mode init
594
597 coming_to_stairs.clear();
598 active_npc.clear();
599 faction_manager_ptr->clear();
604
605 SCT.vSCT.clear(); //Delete pending messages
606
607 stats().clear();
608 // reset kill counts
609 kill_tracker_ptr->clear();
611 // reset follower list
612 follower_ids.clear();
613 scent.reset();
614
616 remoteveh_cache = nullptr;
617
618 token_provider_ptr->clear();
619 // back to menu for save loading, new game etc
620}
void clear_zombies()
Redirects to the creature_tracker clear() function.
Definition: game.cpp:5030
void load_world_modfiles(loading_ui &ui)
Loads core data and mods from the active world.
Definition: game.cpp:2932
static void clear_all()
Remove all active missions, used to cleanup on exit and before reloading a new game.
Definition: mission.cpp:127
void reset()
Definition: scent_map.cpp:51
static const string_id< weather_type > & NULL_ID()
Returns a null id whose string_id<T>::is_null() must always return true.
void clear_messages()
Definition: messages.cpp:351
void reset_sounds()
Definition: sounds.cpp:565

References _, achievements_tracker_ptr, active_npc, calendar::before_time_starts, bVMonsterLookFire, character_id, explosion_handler::explosion_queue::clear(), stats_tracker::clear(), mission::clear_all(), Messages::clear_messages(), clear_zombies(), coming_to_stairs, debugmsg, faction_manager_ptr, follower_ids, explosion_handler::get_explosion_queue(), get_weather, kill_tracker_ptr, load_core_data(), load_world_modfiles(), m, new_game, next_mission_id, next_npc_id, weather_manager::nextweather, string_id< weather_type >::NULL_ID(), popup(), QUIT_NO, ui_manager::redraw(), refresh_display(), remoteveh_cache, remoteveh_cache_time, scent_map::reset(), sounds::reset_sounds(), scent, SCT, calendar::set_eternal_season(), calendar::set_season_length(), stats(), timed_events, token_provider_ptr, turnssincelastmon, uquit, scrollingcombattext::vSCT, and weather_manager::weather_id.

Referenced by butcher_submenu(), and quickload().

◆ shared_from()

template<typename T >
template shared_ptr_fast< npc > game::shared_from< npc > ( const T &  critter)

Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature).

The function may return an empty pointer if the given critter is not stored anywhere (e.g. it was allocated on the stack, not stored in the critter_tracker nor in active_npc nor is it u).

Definition at line 4883 of file game.cpp.

4884{
4885 if( static_cast<const Creature *>( &critter ) == static_cast<const Creature *>( &u ) ) {
4886 // u is not stored in a shared_ptr, but it won't go out of scope anyway
4887 return std::dynamic_pointer_cast<T>( u_shared_ptr );
4888 }
4889 if( critter.is_monster() ) {
4890 if( const shared_ptr_fast<monster> mon_ptr = critter_tracker->find( critter.pos() ) ) {
4891 if( static_cast<const Creature *>( mon_ptr.get() ) == static_cast<const Creature *>( &critter ) ) {
4892 return std::dynamic_pointer_cast<T>( mon_ptr );
4893 }
4894 }
4895 }
4896 if( critter.is_npc() ) {
4897 for( auto &cur_npc : active_npc ) {
4898 if( static_cast<const Creature *>( cur_npc.get() ) == static_cast<const Creature *>( &critter ) ) {
4899 return std::dynamic_pointer_cast<T>( cur_npc );
4900 }
4901 }
4902 }
4903 return nullptr;
4904}

References active_npc, critter_tracker, u, and u_shared_ptr.

Referenced by list_monsters(), mon_info_update(), and validate_mounted_npcs().

◆ shift_destination_preview()

void game::shift_destination_preview ( const point delta)

Definition at line 12539 of file game.cpp.

12540{
12541 for( tripoint &p : destination_preview ) {
12542 p += delta;
12543 }
12544}

References destination_preview.

◆ shift_monsters()

void game::shift_monsters ( const tripoint shift)
private

Shift all active monsters, the shift vector is the number of shifted submaps.

Monsters that are outside of the reality bubble after shifting are despawned. Note on z-levels: this works with vertical shifts, but currently all monsters are despawned upon a vertical shift.

Definition at line 11544 of file game.cpp.

11545{
11546 // If either shift argument is non-zero, we're shifting.
11547 if( shift == tripoint_zero ) {
11548 return;
11549 }
11550 for( monster &critter : all_monsters() ) {
11551 if( shift.xy() != point_zero ) {
11552 critter.shift( shift.xy() );
11553 }
11554
11555 if( m.inbounds( critter.pos() ) && ( shift.z == 0 || m.has_zlevels() ) ) {
11556 // We're inbounds, so don't despawn after all.
11557 // No need to shift Z-coordinates, they are absolute
11558 continue;
11559 }
11560 // Either a vertical shift or the critter is now outside of the reality bubble,
11561 // anyway: it must be saved and removed.
11562 despawn_monster( critter );
11563 }
11564 // The order in which zombies are shifted may cause zombies to briefly exist on
11565 // the same square. This messes up the mon_at cache, so we need to rebuild it.
11566 critter_tracker->rebuild_cache();
11567}

References all_monsters(), critter_tracker, despawn_monster(), map::has_zlevels(), map::inbounds(), m, point_zero, tripoint_zero, tripoint::xy(), and tripoint::z.

Referenced by update_map(), vertical_move(), and vertical_shift().

◆ slip_down()

bool game::slip_down ( )

Checks if player is able to successfully climb to/from some terrain and not slip down.

Returns
whether player has slipped down
Dexterity decreases chances of slipping while climbing

Definition at line 12546 of file game.cpp.

12547{
12548 ///\EFFECT_DEX decreases chances of slipping while climbing
12549 int climb = u.dex_cur;
12550 if( u.has_trait( trait_BADKNEES ) ) {
12551 climb = climb / 2;
12552 }
12553 if( one_in( climb ) ) {
12554 add_msg( m_bad, _( "You slip while climbing and fall down again." ) );
12555 if( climb <= 1 ) {
12556 add_msg( m_bad, _( "Climbing is impossible in your current state." ) );
12557 }
12558 return true;
12559 }
12560 return false;
12561}
static const trait_id trait_BADKNEES("BADKNEES")

References _, add_msg(), Character::dex_cur, Character::has_trait(), m_bad, one_in(), trait_BADKNEES, and u.

◆ spawn_hallucination()

bool game::spawn_hallucination ( const tripoint p)

Spawns a hallucination at a determined position.

Attempts to spawn a hallucination at given location.

Returns false if the hallucination couldn't be spawned for whatever reason, such as a monster already in the target square.

Returns
Whether or not a hallucination was successfully spawned.

Definition at line 5041 of file game.cpp.

5042{
5043 if( one_in( 100 ) ) {
5044 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
5045 tmp->normalize();
5046 tmp->randomize( NC_HALLU );
5047 tmp->spawn_at_precise( { get_levx(), get_levy() }, p );
5048 if( !critter_at( p, true ) ) {
5050 load_npcs();
5051 return true;
5052 } else {
5053 return false;
5054 }
5055 }
5056
5058 const shared_ptr_fast<monster> phantasm = make_shared_fast<monster>( mt );
5059 phantasm->hallucination = true;
5060 phantasm->spawn( p );
5061
5062 //Don't attempt to place phantasms inside of other creatures
5063 if( !critter_at( phantasm->pos(), true ) ) {
5064 return critter_tracker->add( phantasm );
5065 } else {
5066 return false;
5067 }
5068}
mtype_id get_valid_hallucination() const
static MonsterGenerator & generator()
npc_class_id NC_HALLU("NC_HALLU")

References critter_at(), critter_tracker, MonsterGenerator::generator(), get_levx(), get_levy(), MonsterGenerator::get_valid_hallucination(), overmapbuffer::insert_npc(), load_npcs(), NC_HALLU, one_in(), and overmap_buffer.

◆ spell_events_subscriber()

spell_events & game::spell_events_subscriber ( )

Definition at line 3093 of file game.cpp.

3094{
3095 return *spell_events_ptr;
3096}

References spell_events_ptr.

◆ start_calendar()

void game::start_calendar ( )

Definition at line 12108 of file game.cpp.

12109{
12110 const bool scen_season = scen->has_flag( "SPR_START" ) || scen->has_flag( "SUM_START" ) ||
12111 scen->has_flag( "AUT_START" ) || scen->has_flag( "WIN_START" ) ||
12112 scen->has_flag( "SUM_ADV_START" );
12113
12115 if( scen_season ) {
12116 // Configured starting date overridden by scenario, calendar_config.start is left as Spring 1
12118 get_option<int>( "INITIAL_TIME" );
12119 calendar_config._start_of_game = calendar::turn_zero + 1_hours * get_option<int>( "INITIAL_TIME" );
12120 if( scen->has_flag( "SPR_START" ) ) {
12122 } else if( scen->has_flag( "SUM_START" ) ) {
12125 } else if( scen->has_flag( "AUT_START" ) ) {
12128 } else if( scen->has_flag( "WIN_START" ) ) {
12131 } else if( scen->has_flag( "SUM_ADV_START" ) ) {
12134 } else {
12135 debugmsg( "The Unicorn" );
12136 }
12137 } else {
12138 // No scenario, so use the starting date+time configured in world options
12139 int initial_days = get_option<int>( "INITIAL_DAY" );
12140 if( initial_days == -1 ) {
12141 // 0 - 363 for a 91 day season
12142 initial_days = rng( 0, get_option<int>( "SEASON_LENGTH" ) * 4 - 1 );
12143 }
12145
12146 // Determine the season based off how long the seasons are set to be
12147 // First take the number of season elapsed up to the starting date, then mod by 4 to get the season of the current year
12148 const int season_number = ( initial_days / get_option<int>( "SEASON_LENGTH" ) ) % 4;
12149 if( season_number == 0 ) {
12151 } else if( season_number == 1 ) {
12153 } else if( season_number == 2 ) {
12155 } else {
12157 }
12158
12160 + 1_hours * get_option<int>( "INITIAL_TIME" )
12161 + 1_days * get_option<int>( "SPAWN_DELAY" );
12162 }
12163
12165}
@ WINTER
Definition: calendar.h:21
@ AUTUMN
Definition: calendar.h:20
@ SUMMER
Definition: calendar.h:19
@ SPRING
Definition: calendar.h:18
time_duration season_length() const
Definition: calendar.h:569
const scenario * scen
Definition: game.h:1030
bool has_flag(const std::string &flag) const
Such as a seasonal start, fiery start, surrounded start, etc.
Definition: scenario.cpp:439

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, AUTUMN, calendar::config, debugmsg, scenario::has_flag(), rng(), scen, calendar_config::season_length(), SPRING, SUMMER, calendar::turn, calendar::turn_zero, and WINTER.

Referenced by start_game().

◆ start_game()

bool game::start_game ( )
private

Definition at line 645 of file game.cpp.

646{
647 if( !gamemode ) {
648 gamemode = std::make_unique<special_game>();
649 }
650
651 seed = rng_bits();
652 new_game = true;
655 safe_mode = ( get_option<bool>( "SAFEMODE" ) ? SAFE_MODE_ON : SAFE_MODE_OFF );
656 mostseen = 0; // ...and mostseen is 0, we haven't seen any monsters yet.
658
660
663 popup.message( "%s", _( "Please wait as we build your world" ) );
666
667 load_master();
668 u.setID( assign_npc_id() ); // should be as soon as possible, but *after* load_master
669
673 do {
674 omtstart = start_loc.find_player_initial_location();
675 if( omtstart == overmap::invalid_tripoint ) {
676 if( query_yn(
677 _( "Try again?\n\nIt may require several attempts until the game finds a valid starting location." ) ) ) {
680 } else {
681 return false;
682 }
683 }
684 } while( omtstart == overmap::invalid_tripoint );
685
686 start_loc.prepare_map( omtstart );
687
688 // Place vehicles spawned by scenario or profession, has to be placed very early to avoid bugs.
689 if( u.starting_vehicle &&
690 !place_vehicle_nearby( u.starting_vehicle, omtstart.xy(), 0, 30,
691 std::vector<std::string> {} ) ) {
692 debugmsg( "could not place starting vehicle" );
693 }
694
695 if( scen->has_map_extra() ) {
696 // Map extras can add monster spawn points and similar and should be done before the main
697 // map is loaded.
698 start_loc.add_map_extra( omtstart, scen->get_map_extra() );
699 }
700
701 // TODO: fix point types
702 tripoint lev = project_to<coords::sm>( omtstart ).raw();
703 // The player is centered in the map, but lev[xyz] refers to the top left point of the map
704 lev.x -= HALF_MAPSIZE;
705 lev.y -= HALF_MAPSIZE;
706 load_map( lev );
707
710 // Do this after the map cache has been built!
711 start_loc.place_player( u );
712 // ...but then rebuild it, because we want visibility cache to avoid spawning monsters in sight
715 // Start the overmap with out immediate neighborhood visible, this needs to be after place_player
717 get_option<int>( "DISTANCE_INITIAL_VISIBILITY" ), 0 );
718
719 u.moves = 0;
720 u.process_turn(); // process_turn adds the initial move points
724 u.next_climate_control_check = calendar::before_time_starts; // Force recheck at startup
726
727 //Reset character safe mode/pickup rules
732
733 //Put some NPCs in there!
734 if( get_option<std::string>( "STARTING_NPC" ) == "always" ||
735 ( get_option<std::string>( "STARTING_NPC" ) == "scenario" &&
736 !g->scen->has_flag( "LONE_START" ) ) ) {
738 }
739 //Load NPCs. Set nearby npcs to active.
740 load_npcs();
741 // Spawn the monsters
742 const bool spawn_near =
743 get_option<bool>( "BLACK_ROAD" ) || g->scen->has_flag( "SUR_START" );
744 // Surrounded start ones
745 if( spawn_near ) {
746 start_loc.surround_with_monsters( omtstart, mongroup_id( "GROUP_ZOMBIE" ), 70 );
747 }
748
749 m.spawn_monsters( !spawn_near ); // Static monsters
750
751 // Make sure that no monsters are near the player
752 // This can happen in lab starts
753 if( !spawn_near ) {
754 for( monster &critter : all_monsters() ) {
755 if( rl_dist( critter.pos(), u.pos() ) <= 5 ||
756 m.clear_path( critter.pos(), u.pos(), 40, 1, 100 ) ) {
757 remove_zombie( critter );
758 }
759 }
760 }
761
762 //Create mutation_category_level
764 //Calculate mutation drench protection stats
767 if( scen->has_flag( "FIRE_START" ) ) {
768 start_loc.burn( omtstart, 3, 3 );
769 }
770 if( scen->has_flag( "INFECTED" ) ) {
772 }
773 if( scen->has_flag( "BAD_DAY" ) ) {
774 u.add_effect( effect_flu, 1000_minutes );
775 u.add_effect( effect_drunk, 270_minutes );
776 u.add_morale( MORALE_FEELING_BAD, -100, -100, 50_minutes, 50_minutes );
777 }
778 if( scen->has_flag( "HELI_CRASH" ) ) {
779 start_loc.handle_heli_crash( u );
780 bool success = false;
781 for( auto v : m.get_vehicles() ) {
782 std::string name = v.v->type.str();
783 std::string search = std::string( "helicopter" );
784 if( name.find( search ) != std::string::npos ) {
785 for( const vpart_reference &vp : v.v->get_any_parts( VPFLAG_CONTROLS ) ) {
786 const tripoint pos = vp.pos();
787 u.setpos( pos );
788
789 // Delete the items that would have spawned here from a "corpse"
790 for( auto sp : v.v->parts_at_relative( vp.mount(), true ) ) {
791 vehicle_stack here = v.v->get_items( sp );
792
793 for( auto iter = here.begin(); iter != here.end(); ) {
794 iter = here.erase( iter );
795 }
796 }
797
798 auto mons = critter_tracker->find( pos );
799 if( mons != nullptr ) {
800 critter_tracker->remove( *mons );
801 }
802
803 success = true;
804 break;
805 }
806 if( success ) {
807 v.v->name = "Bird Wreckage";
808 break;
809 }
810 }
811 }
812 }
813 if( scen->has_flag( "BORDERED" ) ) {
814 overmap &starting_om = get_cur_om();
815 for( int z = -OVERMAP_DEPTH; z <= OVERMAP_HEIGHT; z++ ) {
816 starting_om.place_special_forced( overmap_special_id( "world" ), { 0, 0, z },
818 }
819
820 }
821 for( auto &e : u.inv_dump() ) {
822 e->set_owner( g->u );
823 }
824 // Now that we're done handling coordinates, ensure the player's submap is in the center of the map
825 update_map( u );
826 // Profession pets
827 for( const mtype_id &elem : u.starting_pets ) {
828 if( monster *const mon = place_critter_around( elem, u.pos(), 5 ) ) {
829 mon->friendly = -1;
830 mon->add_effect( effect_pet, 1_turns, num_bp );
831 } else {
832 add_msg( m_debug, "cannot place starting pet, no space!" );
833 }
834 }
835 // Assign all of this scenario's missions to the player.
836 for( const mission_type_id &m : scen->missions() ) {
837 const auto mission = mission::reserve_new( m, character_id() );
838 mission->assign( u );
839 }
840
841 g->events().send<event_type::game_start>( u.getID() );
842 return true;
843}
body_part random_body_part(bool main_parts_only)
Returns a random body_part token.
Definition: bodypart.cpp:364
bool last_climate_control_ret
Definition: character.h:2276
void drench_mut_calc()
Recalculates mutation drench protection for all bodyparts (ignored/good/neutral stats)
Definition: character.cpp:7937
void set_stamina(int new_stamina)
Definition: character.cpp:7199
time_point next_climate_control_check
Definition: character.h:2275
int get_stamina_max() const
Definition: character.cpp:7190
void set_highest_cat_level()
Recalculates mutation_category_level[] values for the player.
Definition: character.cpp:7914
void default_initialize()
Perform default initialization.
Definition: auto_note.cpp:101
void start_calendar()
Definition: game.cpp:12108
void create_starting_npcs()
Definition: game.cpp:971
overmap & get_cur_om() const
The overmap which contains the center submap of the reality bubble.
Definition: game.cpp:12406
vehicle * place_vehicle_nearby(const vproto_id &id, const point_abs_omt &origin, int min_distance, int max_distance, const std::vector< std::string > &omt_search_types={})
Definition: game.cpp:845
bool clear_path(const tripoint &f, const tripoint &t, int range, int cost_min, int cost_max) const
Check whether there's a direct line of sight between F and T with the additional movecost restraints.
Definition: map.cpp:6365
static mission * reserve_new(const mission_type_id &type, const character_id &npc_id)
Create a new mission of the given type and assign it to the given npc.
Definition: mission.cpp:64
void assign(avatar &u)
Assigns the mission to the player.
Definition: mission.cpp:210
void place_special_forced(const overmap_special_id &special_id, const tripoint_om_omt &p, om_direction::type dir)
Definition: overmap.cpp:2153
bool reveal(const point_abs_omt &center, int radius, int z)
Mark a square area around center on Z-level z as seen.
bool random_start_location
Definition: player.h:687
vproto_id starting_vehicle
Definition: player.h:699
std::vector< mtype_id > starting_pets
Definition: player.h:700
start_location_id start_location
Definition: player.h:688
void clear_character_rules()
bool has_map_extra() const
Definition: scenario.cpp:454
const std::string & get_map_extra() const
Definition: scenario.cpp:458
const std::vector< mission_type_id > & missions() const
Definition: scenario.cpp:462
start_location_id random_start_location() const
Definition: scenario.cpp:232
void burn(const tripoint_abs_omt &omtstart, size_t count, int rad) const
Burn random terrain / furniture with FLAMMABLE or FLAMMABLE_ASH tag.
void surround_with_monsters(const tripoint_abs_omt &omtstart, const mongroup_id &type, float expected_points) const
Adds surround start monsters.
void prepare_map(const tripoint_abs_omt &omtstart) const
Initialize the map at players start location using prepare_map.
void place_player(player &u) const
Place the player somewhere in the reality bubble (g->m).
void handle_heli_crash(player &u) const
tripoint_abs_omt find_player_initial_location() const
Find a suitable start location on the overmap.
void add_map_extra(const tripoint_abs_omt &omtstart, const std::string &map_extra) const
Adds a map extra, see map_extras.h and map_extras.cpp.
const T & obj() const
Returns the actual object this id refers to.
Definition: achievement.cpp:58
iterator erase(const_iterator it) override
Definition: vehicle.cpp:230
static const efftype_id effect_drunk("drunk")
static const efftype_id effect_infected("infected")
static const efftype_id effect_accumulated_mutagen("accumulated_mutagen")
static const efftype_id effect_flu("flu")
static constexpr int SPRING_TEMPERATURE
Base starting spring temperature in F used for climate, weather and temperature calculation.
void update_weather()
Definition: weather.cpp:1056
const morale_type MORALE_FEELING_BAD("morale_feeling_bad")
static bool search(const ui_adaptor &om_ui, tripoint_abs_omt &curs, const tripoint_abs_omt &orig)
string_id< overmap_special > overmap_special_id
Definition: omdata.h:37
unsigned int rng_bits()
Definition: rng.cpp:12
string_id< MonsterGroup > mongroup_id
Definition: type_id.h:98
@ VPFLAG_CONTROLS
Definition: veh_type.h:41

References _, Creature::add_effect(), start_location::add_map_extra(), Character::add_morale(), add_msg(), all_monsters(), mission::assign(), assign_npc_id(), calendar::before_time_starts, item_stack::begin(), map::build_map_cache(), start_location::burn(), character_id, auto_notes::auto_note_settings::clear(), overmapbuffer::clear(), auto_pickup::player_settings::clear_character_rules(), safemode::clear_character_rules(), map::clear_path(), create_starting_npcs(), critter_tracker, debugmsg, auto_notes::auto_note_settings::default_initialize(), Character::drench_mut_calc(), effect_accumulated_mutagen, effect_drunk, effect_flu, effect_infected, effect_pet, item_stack::end(), vehicle_stack::erase(), start_location::find_player_initial_location(), g, game_start, gamemode, get_auto_notes_settings(), get_auto_pickup(), get_cur_om(), get_levz(), scenario::get_map_extra(), get_safemode(), Character::get_stamina_max(), map::get_vehicles(), get_weather, Character::getID(), Character::global_omt_location(), HALF_MAPSIZE, start_location::handle_heli_crash(), scenario::has_flag(), scenario::has_map_extra(), init_autosave(), Character::inv_dump(), overmap::invalid_tripoint, map::invalidate_map_cache(), Character::last_climate_control_ret, safemode::load_global(), load_map(), load_master(), load_npcs(), m, m_debug, MAPBUFFER, scenario::missions(), MORALE_FEELING_BAD, mostseen, Creature::moves, om_direction::name(), new_game, Character::next_climate_control_check, weather_manager::nextweather, om_direction::north, num_bp, string_id< T >::obj(), overmap_buffer, OVERMAP_DEPTH, OVERMAP_HEIGHT, place_critter_around(), start_location::place_player(), overmap::place_special_forced(), place_vehicle_nearby(), popup(), Character::pos(), start_location::prepare_map(), player::process_turn(), query_yn(), random_body_part(), player::random_start_location, scenario::random_start_location(), ui_manager::redraw(), refresh_display(), remove_zombie(), mission::reserve_new(), mapbuffer::reset(), overmapbuffer::reveal(), rl_dist(), rng_bits(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, scen, overmap_ui::search(), seed, Character::set_highest_cat_level(), Character::set_stamina(), Character::setID(), Character::setpos(), map::spawn_monsters(), SPRING_TEMPERATURE, start_calendar(), player::start_location, player::starting_pets, player::starting_vehicle, behavior::success, start_location::surround_with_monsters(), weather_manager::temperature, calendar::turn, u, update_map(), weather_manager::update_weather(), VPFLAG_CONTROLS, tripoint::x, coords::coord_point< Point, Origin, Scale >::xy(), and tripoint::y.

◆ start_hauling()

void game::start_hauling ( const tripoint pos)

Definition at line 10907 of file game.cpp.

10908{
10909 // Find target items and quantities thereof for the new activity
10910 std::vector<item_location> target_items;
10911 std::vector<int> quantities;
10912
10913 map_stack items = m.i_at( pos );
10914 for( item &it : items ) {
10915 // Liquid cannot be picked up
10916 if( it.made_of( LIQUID ) ) {
10917 continue;
10918 }
10919 target_items.emplace_back( map_cursor( pos ), &it );
10920 // Quantity of 0 means move all
10921 quantities.push_back( 0 );
10922 }
10923
10924 if( target_items.empty() ) {
10925 // Nothing to haul
10926 return;
10927 }
10928
10929 // Whether the destination is inside a vehicle (not supported)
10930 const bool to_vehicle = false;
10931 // Destination relative to the player
10932 const tripoint relative_destination{};
10933
10935 target_items,
10936 quantities,
10937 to_vehicle,
10938 relative_destination
10939 ) ) );
10940}

References Character::assign_activity(), map::i_at(), LIQUID, m, and u.

Referenced by vertical_move(), and walk_move().

◆ stats()

stats_tracker & game::stats ( )

Definition at line 3083 of file game.cpp.

3084{
3085 return *stats_tracker_ptr;
3086}

References stats_tracker_ptr.

Referenced by death_screen(), handle_action(), setup(), and win().

◆ swap_critters()

bool game::swap_critters ( Creature a,
Creature b 
)

Swaps positions of two creatures.

Definition at line 5070 of file game.cpp.

5071{
5072 if( &a == &b ) {
5073 // No need to do anything, but print a debugmsg anyway
5074 debugmsg( "Tried to swap %s with itself", a.disp_name() );
5075 return true;
5076 }
5077 if( critter_at( a.pos() ) != &a ) {
5078 debugmsg( "Tried to swap when it would cause a collision between %s and %s.",
5079 b.disp_name(), critter_at( a.pos() )->disp_name() );
5080 return false;
5081 }
5082 if( critter_at( b.pos() ) != &b ) {
5083 debugmsg( "Tried to swap when it would cause a collision between %s and %s.",
5084 a.disp_name(), critter_at( b.pos() )->disp_name() );
5085 return false;
5086 }
5087 // Simplify by "sorting" the arguments
5088 // Only the first argument can be u
5089 // If swapping player/npc with a monster, monster is second
5090 bool a_first = a.is_player() ||
5091 ( a.is_npc() && !b.is_player() );
5092 Creature &first = a_first ? a : b;
5093 Creature &second = a_first ? b : a;
5094 // Possible options:
5095 // both first and second are monsters
5096 // second is a monster, first is a player or an npc
5097 // first is a player, second is an npc
5098 // both first and second are npcs
5099 if( first.is_monster() ) {
5100 monster *m1 = dynamic_cast< monster * >( &first );
5101 monster *m2 = dynamic_cast< monster * >( &second );
5102 if( m1 == nullptr || m2 == nullptr || m1 == m2 ) {
5103 debugmsg( "Couldn't swap two monsters" );
5104 return false;
5105 }
5106
5107 critter_tracker->swap_positions( *m1, *m2 );
5108 return true;
5109 }
5110
5111 player *u_or_npc = dynamic_cast< player * >( &first );
5112 player *other_npc = dynamic_cast< player * >( &second );
5113
5114 if( u_or_npc->in_vehicle ) {
5115 m.unboard_vehicle( u_or_npc->pos() );
5116 }
5117
5118 if( other_npc && other_npc->in_vehicle ) {
5119 m.unboard_vehicle( other_npc->pos() );
5120 }
5121
5122 tripoint temp = second.pos();
5123 second.setpos( first.pos() );
5124
5125 if( first.is_player() ) {
5126 walk_move( temp );
5127 } else {
5128 first.setpos( temp );
5129 if( m.veh_at( u_or_npc->pos() ).part_with_feature( VPFLAG_BOARDABLE, true ) ) {
5130 m.board_vehicle( u_or_npc->pos(), u_or_npc );
5131 }
5132 }
5133
5134 if( other_npc && m.veh_at( other_npc->pos() ).part_with_feature( VPFLAG_BOARDABLE, true ) ) {
5135 m.board_vehicle( other_npc->pos(), other_npc );
5136 }
5137 return true;
5138}
virtual bool is_monster() const
Definition: creature.h:101
virtual bool is_player() const
Definition: creature.h:92
virtual void setpos(const tripoint &pos)=0
bool walk_move(const tripoint &dest, bool via_ramp=false)
Definition: game.cpp:9309
@ VPFLAG_BOARDABLE
Definition: veh_type.h:39

References a, b, map::board_vehicle(), critter_at(), critter_tracker, debugmsg, Character::in_vehicle, Creature::is_monster(), Creature::is_player(), m, optional_vpart_position::part_with_feature(), Creature::pos(), Character::pos(), second, Creature::setpos(), map::unboard_vehicle(), map::veh_at(), VPFLAG_BOARDABLE, and walk_move().

Referenced by npc_menu().

◆ take_screenshot() [1/2]

bool game::take_screenshot ( ) const

Saves a screenshot of the current viewport, as a PNG file.

Filesystem location is derived from the current world and character.

Note
: Only works for SDL/TILES (otherwise the function returns false). A window (more precisely, a viewport) must already exist and the SDL renderer must be valid.
Returns
true if the screenshot generation was successful, false otherwise.

Definition at line 7407 of file game.cpp.

7408{
7409 popup( _( "This binary was not compiled with tiles support." ) );
7410 return false;
7411}

References _, and popup().

Referenced by do_turn().

◆ take_screenshot() [2/2]

bool game::take_screenshot ( const std::string &  file_path) const

Saves a screenshot of the current viewport, as a PNG file, to the given location.

Parameters
file_pathA full path to the file where the screenshot should be saved.
Note
: Only works for SDL/TILES (otherwise the function returns false). A window (more precisely, a viewport) must already exist and the SDL renderer must be valid.
Returns
true if the screenshot generation was successful, false otherwise.

Definition at line 7401 of file game.cpp.

7402{
7403 popup( _( "This binary was not compiled with tiles support." ) );
7404 return false;
7405}

References _, and popup().

◆ temp_exit_fullscreen()

void game::temp_exit_fullscreen ( )

Definition at line 536 of file game.cpp.

537{
538 if( fullscreen ) {
539 was_fullscreen = true;
541 } else {
542 was_fullscreen = false;
543 }
544}

References fullscreen, toggle_fullscreen(), and was_fullscreen.

Referenced by list_items_monsters(), and look_around().

◆ toggle_debug_hour_timer()

void game::toggle_debug_hour_timer ( )

Definition at line 11715 of file game.cpp.

11716{
11718}

References game::debug_hour_timer::toggle().

Referenced by handle_action(), and look_around().

◆ toggle_fullscreen()

void game::toggle_fullscreen ( )

Definition at line 498 of file game.cpp.

499{
500#if !defined(TILES)
503#else
504 toggle_fullscreen_window();
505#endif
506}

References fullscreen, and mark_main_ui_adaptor_resize().

Referenced by handle_action(), reenter_fullscreen(), and temp_exit_fullscreen().

◆ toggle_pixel_minimap()

void game::toggle_pixel_minimap ( )

Definition at line 508 of file game.cpp.

509{
510#if defined(TILES)
512 clear_window_area( w_pixel_minimap );
513 }
516#endif // TILES
517}

References mark_main_ui_adaptor_resize(), pixel_minimap_option, and w_pixel_minimap.

Referenced by handle_action(), and look_around().

◆ try_get_left_click_action()

bool game::try_get_left_click_action ( action_id act,
const tripoint mouse_target 
)
private

Definition at line 2605 of file game.cpp.

2606{
2607 bool new_destination = true;
2608 if( !destination_preview.empty() ) {
2609 auto &final_destination = destination_preview.back();
2610 if( final_destination.x == mouse_target.x && final_destination.y == mouse_target.y ) {
2611 // Second click
2612 new_destination = false;
2614 destination_preview.clear();
2616 if( act == ACTION_NULL ) {
2617 // Something went wrong
2619 return false;
2620 }
2621 }
2622 }
2623
2624 if( new_destination ) {
2626 u.get_path_avoid() );
2627 return false;
2628 }
2629
2630 return true;
2631}

References act, ACTION_NULL, Character::clear_destination(), destination_preview, Character::get_next_auto_move_direction(), Character::get_path_avoid(), Character::get_pathfinding_settings(), m, Character::pos(), map::route(), Character::set_destination(), u, tripoint::x, and tripoint::y.

Referenced by handle_action().

◆ try_get_right_click_action()

bool game::try_get_right_click_action ( action_id act,
const tripoint mouse_target 
)
private

Definition at line 2633 of file game.cpp.

2634{
2635 const bool cleared_destination = !destination_preview.empty();
2637 destination_preview.clear();
2638
2639 if( cleared_destination ) {
2640 // Produce no-op if auto-move had just been cleared on this action
2641 // e.g. from a previous single left mouse click. This has the effect
2642 // of right-click canceling an auto-move before it is initiated.
2643 return false;
2644 }
2645
2646 const bool is_adjacent = square_dist( mouse_target.xy(), point( u.posx(), u.posy() ) ) <= 1;
2647 const bool is_self = square_dist( mouse_target.xy(), point( u.posx(), u.posy() ) ) <= 0;
2648 if( const monster *const mon = critter_at<monster>( mouse_target ) ) {
2649 if( !u.sees( *mon ) ) {
2650 add_msg( _( "Nothing relevant here." ) );
2651 return false;
2652 }
2653
2654 if( !u.weapon.is_gun() ) {
2655 add_msg( m_info, _( "You are not wielding a ranged weapon." ) );
2656 return false;
2657 }
2658
2659 // TODO: Add weapon range check. This requires weapon to be reloaded.
2660
2661 act = ACTION_FIRE;
2662 } else if( is_adjacent &&
2663 m.close_door( tripoint( mouse_target.xy(), u.posz() ), !m.is_outside( u.pos() ),
2664 true ) ) {
2665 act = ACTION_CLOSE;
2666 } else if( is_self ) {
2668 } else if( is_adjacent ) {
2670 } else {
2671 add_msg( _( "Nothing relevant here." ) );
2672 return false;
2673 }
2674
2675 return true;
2676}
bool close_door(const tripoint &p, bool inside, bool check_only)
Definition: map.cpp:3952
static bool is_adjacent(const monster &z, const Creature &target)

References _, act, ACTION_CLOSE, ACTION_EXAMINE, ACTION_FIRE, ACTION_PICKUP, add_msg(), Character::clear_destination(), map::close_door(), destination_preview, is_adjacent(), item::is_gun(), map::is_outside(), m, m_info, Character::pos(), Character::posx(), Character::posy(), Character::posz(), Character::sees(), square_dist(), u, Character::weapon, and tripoint::xy().

Referenced by handle_action().

◆ unload()

bool game::unload ( item_location  loc)

Definition at line 9005 of file game.cpp.

9006{
9007 return u.unload( loc );
9008}
bool unload(item_location loc)
Definition: player.cpp:3047

References u, and player::unload().

Referenced by inventory_item_menu().

◆ unload_npcs()

void game::unload_npcs ( )
private

Unloads all NPCs.

If you call this you must later call load_npcs, lest caches get rather confused. The tests used to call this a lot when they shouldn't. It is now private to reduce the chance of similar problems in the future.

Definition at line 949 of file game.cpp.

950{
951 for( const auto &npc : active_npc ) {
952 npc->on_unload();
953 }
954
955 active_npc.clear();
956}
void on_unload()
Do some cleanup and caching as npc is being unloaded from map.
Definition: npc.cpp:2642

References active_npc, and npc::on_unload().

Referenced by place_player_overmap(), and reload_npcs().

◆ unserialize()

void game::unserialize ( std::istream &  fin)

Definition at line 167 of file savegame.cpp.

168{
169 chkversion( fin );
170 int tmpturn = 0;
171 int tmpcalstart = 0;
172 int tmprun = 0;
173 tripoint lev;
174 point com;
175 JsonIn jsin( fin );
176 try {
177 JsonObject data = jsin.get_object();
178
179 data.read( "turn", tmpturn );
180 data.read( "calendar_start", tmpcalstart );
182 calendar_config._initial_season = static_cast<season_type>( data.get_int( "initial_season",
183 static_cast<int>( SPRING ) ) );
184 // 0.E stable
185 if( savegame_loading_version < 26 ) {
186 tmpturn *= 6;
187 tmpcalstart *= 6;
188 }
191 tmpcalstart );
192
193 if( !data.read( "game_start", calendar_config._start_of_game ) ) {
195 }
196
197 data.read( "auto_travel_mode", auto_travel_mode );
198 data.read( "run_mode", tmprun );
199 data.read( "mostseen", mostseen );
200 data.read( "levx", lev.x );
201 data.read( "levy", lev.y );
202 data.read( "levz", lev.z );
203 data.read( "om_x", com.x );
204 data.read( "om_y", com.y );
205
206 load_map( tripoint( lev.x + com.x * OMAPX * 2, lev.y + com.y * OMAPY * 2, lev.z ) );
207
208 safe_mode = static_cast<safe_mode_type>( tmprun );
209 if( get_option<bool>( "SAFEMODE" ) && safe_mode == SAFE_MODE_OFF ) {
211 }
212
213 std::string linebuff;
214 std::string linebuf;
215 if( data.read( "grscent", linebuf ) && data.read( "typescent", linebuff ) ) {
216 scent.deserialize( linebuf );
217 scent.deserialize( linebuff, true );
218 } else {
219 scent.reset();
220 }
221 data.read( "active_monsters", *critter_tracker );
222
223 coming_to_stairs.clear();
224 for( auto elem : data.get_array( "stair_monsters" ) ) {
225 monster stairtmp;
226 elem.read( stairtmp );
227 coming_to_stairs.push_back( stairtmp );
228 }
229
230 if( data.has_object( "kill_tracker" ) ) {
231 data.read( "kill_tracker", *kill_tracker_ptr );
232 } else {
233 // Legacy support for when kills were stored directly in game
234 std::map<mtype_id, int> kills;
235 std::vector<std::string> npc_kills;
236 for( const JsonMember member : data.get_object( "kills" ) ) {
237 kills[mtype_id( member.name() )] = member.get_int();
238 }
239
240 for( const std::string npc_name : data.get_array( "npc_kills" ) ) {
241 npc_kills.push_back( npc_name );
242 }
243
244 kill_tracker_ptr->reset( kills, npc_kills );
245 }
246
247 data.read( "player", u );
248 data.read( "stats_tracker", *stats_tracker_ptr );
249 data.read( "achievements_tracker", *achievements_tracker_ptr );
250 data.read( "token_provider", token_provider_ptr );
251 Messages::deserialize( data );
252
253 } catch( const JsonError &jsonerr ) {
254 debugmsg( "Bad save json\n%s", jsonerr.c_str() );
255 return;
256 }
257}
season_type
Real world seasons.
Definition: calendar.h:17
Represents a member of a JsonObject.
Definition: json.h:1249
JsonObject get_object(const std::string &name) const
Definition: json.cpp:361
bool has_object(const std::string &name) const
Definition: json.cpp:425
JsonArray get_array(const std::string &name) const
Definition: json.cpp:332
int get_int(const std::string &name) const
Definition: json.cpp:282
bool read(const std::string &name, T &t, bool throw_on_error=true) const
Definition: json.h:944
void deserialize(const std::string &data, bool is_type=false)
Definition: savegame.cpp:259
safe_mode_type
Definition: game.h:76
static constexpr int OMAPY
static constexpr int OMAPX
Size of the overmap.
void deserialize(const JsonObject &json)
Definition: messages.cpp:330
std::string member
Definition: mapgen.cpp:402
static void chkversion(std::istream &fin)
Definition: savegame.cpp:148
int savegame_loading_version
Definition: savegame.cpp:64

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, achievements_tracker_ptr, auto_travel_mode, JsonError::c_str(), chkversion(), coming_to_stairs, calendar::config, critter_tracker, debugmsg, Messages::deserialize(), scent_map::deserialize(), time_duration::from_turns(), JsonObject::get_array(), JsonObject::get_int(), JsonIn::get_object(), JsonObject::get_object(), JsonObject::has_object(), kill_tracker_ptr, load_map(), mapgen_defer::member, mostseen, mtype_id, OMAPX, OMAPY, JsonObject::read(), scent_map::reset(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, savegame_loading_version, scent, SPRING, stats_tracker_ptr, token_provider_ptr, calendar::turn, calendar::turn_zero, u, point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

Referenced by load().

◆ unserialize_master()

void game::unserialize_master ( std::istream &  fin)

Definition at line 1207 of file savegame.cpp.

1208{
1210 chkversion( fin );
1211 if( savegame_loading_version < 11 ) {
1212 std::unique_ptr<static_popup>popup = std::make_unique<static_popup>();
1213 popup->message(
1214 _( "Cannot find loader for save data in old version %d, attempting to load as current version %d." ),
1218 }
1219 try {
1220 // single-pass parsing example
1221 JsonIn jsin( fin );
1222 jsin.start_object();
1223 while( !jsin.end_object() ) {
1224 std::string name = jsin.get_member_name();
1225 if( name == "next_mission_id" ) {
1226 next_mission_id = jsin.get_int();
1227 } else if( name == "next_npc_id" ) {
1228 next_npc_id.deserialize( jsin );
1229 } else if( name == "active_missions" ) {
1231 } else if( name == "factions" ) {
1232 jsin.read( *faction_manager_ptr );
1233 } else if( name == "seed" ) {
1234 jsin.read( seed );
1235 } else if( name == "weather" ) {
1236 JsonObject w = jsin.get_object();
1237 w.read( "lightning", get_weather().lightning_active );
1238 } else {
1239 // silently ignore anything else
1240 jsin.skip_value();
1241 }
1242 }
1243 } catch( const JsonError &e ) {
1244 debugmsg( "error loading %s: %s", SAVE_MASTER, e.c_str() );
1245 }
1246}
void deserialize(JsonIn &)
static void unserialize_all(JsonIn &jsin)
Definition: savegame.cpp:1197

References _, JsonError::c_str(), chkversion(), debugmsg, character_id::deserialize(), JsonIn::end_object(), faction_manager_ptr, JsonIn::get_int(), JsonIn::get_member_name(), JsonIn::get_object(), get_weather, om_direction::name(), next_mission_id, next_npc_id, popup(), JsonIn::read(), JsonObject::read(), ui_manager::redraw(), refresh_display(), SAVE_MASTER(), savegame_loading_version, savegame_version, seed, JsonIn::skip_value(), JsonIn::start_object(), and mission::unserialize_all().

Referenced by load_master().

◆ update_map() [1/2]

point game::update_map ( int &  x,
int &  y 
)

Definition at line 11175 of file game.cpp.

11176{
11177 point shift;
11178
11179 while( x < HALF_MAPSIZE_X ) {
11180 x += SEEX;
11181 shift.x--;
11182 }
11183 while( x >= HALF_MAPSIZE_X + SEEX ) {
11184 x -= SEEX;
11185 shift.x++;
11186 }
11187 while( y < HALF_MAPSIZE_Y ) {
11188 y += SEEY;
11189 shift.y--;
11190 }
11191 while( y >= HALF_MAPSIZE_Y + SEEY ) {
11192 y -= SEEY;
11193 shift.y++;
11194 }
11195
11196 if( shift == point_zero ) {
11197 // adjust player position
11198 u.setpos( tripoint( x, y, get_levz() ) );
11199 // Update what parts of the world map we can see
11200 // We need this call because even if the map hasn't shifted we may have changed z-level and can now see farther
11201 // TODO: only make this call if we changed z-level
11203 // Not actually shifting the submaps, all the stuff below would do nothing
11204 return point_zero;
11205 }
11206
11207 // this handles loading/unloading submaps that have scrolled on or off the viewport
11208 // NOLINTNEXTLINE(cata-use-named-point-constants)
11209 inclusive_rectangle<point> size_1( point( -1, -1 ), point( 1, 1 ) );
11210 point remaining_shift = shift;
11211 while( remaining_shift != point_zero ) {
11212 point this_shift = clamp( remaining_shift, size_1 );
11213 m.shift( this_shift );
11214 remaining_shift -= this_shift;
11215 }
11216
11217 grid_tracker_ptr->load( m );
11218
11219 // Shift monsters
11220 shift_monsters( tripoint( shift, 0 ) );
11221 const point shift_ms = sm_to_ms_copy( shift );
11222 u.shift_destination( -shift_ms );
11223
11224 // Shift NPCs
11225 for( auto it = active_npc.begin(); it != active_npc.end(); ) {
11226 ( *it )->shift( shift );
11227 if( ( *it )->posx() < 0 - SEEX * 2 || ( *it )->posy() < 0 - SEEX * 2 ||
11228 ( *it )->posx() > SEEX * ( MAPSIZE + 2 ) || ( *it )->posy() > SEEY * ( MAPSIZE + 2 ) ) {
11229 //Remove the npc from the active list. It remains in the overmap list.
11230 ( *it )->on_unload();
11231 it = active_npc.erase( it );
11232 } else {
11233 it++;
11234 }
11235 }
11236
11237 scent.shift( shift_ms );
11238
11239 // Also ensure the player is on current z-level
11240 // get_levz() should later be removed, when there is no longer such a thing
11241 // as "current z-level"
11242 u.setpos( tripoint( x, y, get_levz() ) );
11243
11244 // Only do the loading after all coordinates have been shifted.
11245
11246 // Check for overmap saved npcs that should now come into view.
11247 // Put those in the active list.
11248 load_npcs();
11249
11250 // Make sure map cache is consistent since it may have shifted.
11251 if( m.has_zlevels() ) {
11252 for( int zlev = -OVERMAP_DEPTH; zlev <= OVERMAP_HEIGHT; ++zlev ) {
11253 m.invalidate_map_cache( zlev );
11254 }
11255 } else {
11257 }
11259
11260 // Spawn monsters if appropriate
11261 // This call will generate new monsters in addition to loading, so it's placed after NPC loading
11262 m.spawn_monsters( false ); // Static monsters
11263
11264 // Update what parts of the world map we can see
11266
11267 return shift;
11268}
void shift_destination(const point &shift)
void shift_monsters(const tripoint &shift)
Shift all active monsters, the shift vector is the number of shifted submaps.
Definition: game.cpp:11544
void shift(const point &s)
Shift the map along the vector s.
Definition: map.cpp:6653
void shift(const point &sm_shift)
Definition: scent_map.cpp:82
point sm_to_ms_copy(const point &p)
static constexpr int HALF_MAPSIZE_Y
static constexpr int HALF_MAPSIZE_X

References active_npc, map::build_map_cache(), clamp(), get_levz(), grid_tracker_ptr, HALF_MAPSIZE_X, HALF_MAPSIZE_Y, map::has_zlevels(), map::invalidate_map_cache(), load_npcs(), m, MAPSIZE, OVERMAP_DEPTH, OVERMAP_HEIGHT, point_zero, scent, SEEX, SEEY, Character::setpos(), map::shift(), scent_map::shift(), Character::shift_destination(), shift_monsters(), sm_to_ms_copy(), map::spawn_monsters(), u, update_overmap_seen(), point::x, and point::y.

◆ update_map() [2/2]

point game::update_map ( player p)

Definition at line 11169 of file game.cpp.

11170{
11171 point p2( p.posx(), p.posy() );
11172 return update_map( p2.x, p2.y );
11173}

References Character::posx(), Character::posy(), update_map(), point::x, and point::y.

Referenced by fling_creature(), load(), place_player(), start_game(), update_map(), and vertical_move().

◆ update_overmap_seen()

void game::update_overmap_seen ( )

Definition at line 11270 of file game.cpp.

11271{
11272 const tripoint_abs_omt ompos = u.global_omt_location();
11273 const int dist = u.overmap_sight_range( light_level( u.posz() ) );
11274 const int dist_squared = dist * dist;
11275 // We can always see where we're standing
11276 overmap_buffer.set_seen( ompos, true );
11277 for( const tripoint_abs_omt &p : points_in_radius( ompos, dist ) ) {
11278 const point_rel_omt delta = p.xy() - ompos.xy();
11279 const int h_squared = delta.x() * delta.x() + delta.y() * delta.y();
11280 if( trigdist && h_squared > dist_squared ) {
11281 continue;
11282 }
11283 if( delta == point_rel_omt() ) {
11284 // 1. This case is already handled outside of the loop
11285 // 2. Calculating multiplier would cause division by zero
11286 continue;
11287 }
11288 // If circular distances are enabled, scale overmap distances by the diagonality of the sight line.
11289 point abs_delta = delta.raw().abs();
11290 int max_delta = std::max( abs_delta.x, abs_delta.y );
11291 const float multiplier = trigdist ? std::sqrt( h_squared ) / max_delta : 1;
11292 const std::vector<tripoint_abs_omt> line = line_to( ompos, p );
11293 float sight_points = dist;
11294 for( auto it = line.begin();
11295 it != line.end() && sight_points >= 0; ++it ) {
11296 const oter_id &ter = overmap_buffer.ter( *it );
11297 sight_points -= static_cast<int>( ter->get_see_cost() ) * multiplier;
11298 }
11299 if( sight_points >= 0 ) {
11300 tripoint_abs_omt seen( p );
11301 do {
11302 overmap_buffer.set_seen( seen, true );
11303 --seen.z();
11304 } while( seen.z() >= 0 );
11305 }
11306 }
11307}
bool trigdist
Circular distances.
int overmap_sight_range(int light_level) const
Returns the distance the player can see on the overmap.
Definition: character.cpp:764
constexpr Point & raw()
Definition: coordinates.h:111
void set_seen(const tripoint_abs_omt &p, bool seen=true)
coords::coord_point< point, coords::origin::relative, coords::omt > point_rel_omt
Definition: coordinates.h:478
tripoint_range< Tripoint > points_in_radius(const Tripoint &center, const int radius, const int radiusz=0)
Definition: map_iterator.h:125
unsigned char get_see_cost() const
Definition: omdata.h:234

References oter_t::get_see_cost(), Character::global_omt_location(), light_level(), line(), line_to(), overmap_buffer, Character::overmap_sight_range(), points_in_radius(), Character::posz(), coords::coord_point< Point, Origin, Scale >::raw(), overmapbuffer::set_seen(), overmapbuffer::ter(), trigdist, u, coords::coord_point< Point, Origin, Scale >::x(), point::x, coords::coord_point< Point, Origin, Scale >::xy(), coords::coord_point< Point, Origin, Scale >::y(), point::y, and coords::coord_point< Point, Origin, Scale >::z().

Referenced by place_player_overmap(), and update_map().

◆ update_stair_monsters()

void game::update_stair_monsters ( )
private
Dodge reduces chance of being downed when pushed off the stairs

Definition at line 11322 of file game.cpp.

11323{
11324 // Search for the stairs closest to the player.
11325 std::vector<int> stairx;
11326 std::vector<int> stairy;
11327 std::vector<int> stairdist;
11328
11329 const bool from_below = monstairz < get_levz();
11330
11331 if( coming_to_stairs.empty() ) {
11332 return;
11333 }
11334
11335 if( m.has_zlevels() ) {
11336 debugmsg( "%d monsters coming to stairs on a map with z-levels",
11337 coming_to_stairs.size() );
11338 coming_to_stairs.clear();
11339 }
11340
11341 for( const tripoint &dest : m.points_on_zlevel( u.posz() ) ) {
11342 if( ( from_below && m.has_flag( "GOES_DOWN", dest ) ) ||
11343 ( !from_below && m.has_flag( "GOES_UP", dest ) ) ) {
11344 stairx.push_back( dest.x );
11345 stairy.push_back( dest.y );
11346 stairdist.push_back( rl_dist( dest, u.pos() ) );
11347 }
11348 }
11349 if( stairdist.empty() ) {
11350 return; // Found no stairs?
11351 }
11352
11353 // Find closest stairs.
11354 size_t si = 0;
11355 for( size_t i = 0; i < stairdist.size(); i++ ) {
11356 if( stairdist[i] < stairdist[si] ) {
11357 si = i;
11358 }
11359 }
11360
11361 // Find up to 4 stairs for distance stairdist[si] +1
11362 std::vector<int> nearest;
11363 nearest.push_back( si );
11364 for( size_t i = 0; i < stairdist.size() && nearest.size() < 4; i++ ) {
11365 if( ( i != si ) && ( stairdist[i] <= stairdist[si] + 1 ) ) {
11366 nearest.push_back( i );
11367 }
11368 }
11369 // Randomize the stair choice
11370 si = random_entry_ref( nearest );
11371
11372 // Attempt to spawn zombies.
11373 for( size_t i = 0; i < coming_to_stairs.size(); i++ ) {
11374 point mpos( stairx[si], stairy[si] );
11375 monster &critter = coming_to_stairs[i];
11376 const tripoint dest {
11377 mpos, g->get_levz()
11378 };
11379
11380 // We might be not be visible.
11381 if( ( critter.posx() < 0 - ( MAPSIZE_X ) / 6 ||
11382 critter.posy() < 0 - ( MAPSIZE_Y ) / 6 ||
11383 critter.posx() > ( MAPSIZE_X * 7 ) / 6 ||
11384 critter.posy() > ( MAPSIZE_Y * 7 ) / 6 ) ) {
11385 continue;
11386 }
11387
11388 critter.staircount -= 4;
11389 // Let the player know zombies are trying to come.
11390 if( u.sees( dest ) ) {
11391 std::string dump;
11392 if( critter.staircount > 4 ) {
11393 dump += string_format( _( "You see a %s on the stairs" ), critter.name() );
11394 } else {
11395 if( critter.staircount > 0 ) {
11396 dump += ( from_below ?
11397 //~ The <monster> is almost at the <bottom/top> of the <terrain type>!
11398 string_format( _( "The %1$s is almost at the top of the %2$s!" ),
11399 critter.name(),
11400 m.tername( dest ) ) :
11401 string_format( _( "The %1$s is almost at the bottom of the %2$s!" ),
11402 critter.name(),
11403 m.tername( dest ) ) );
11404 }
11405 }
11406
11407 add_msg( m_warning, dump );
11408 } else {
11410 _( "a sound nearby from the stairs!" ), true, "misc", "stairs_movement" );
11411 }
11412
11413 if( critter.staircount > 0 ) {
11414 continue;
11415 }
11416
11417 if( is_empty( dest ) ) {
11418 critter.spawn( dest );
11419 critter.staircount = 0;
11420 place_critter_at( make_shared_fast<monster>( critter ), dest );
11421 if( u.sees( dest ) ) {
11422 if( !from_below ) {
11423 add_msg( m_warning, _( "The %1$s comes down the %2$s!" ),
11424 critter.name(),
11425 m.tername( dest ) );
11426 } else {
11427 add_msg( m_warning, _( "The %1$s comes up the %2$s!" ),
11428 critter.name(),
11429 m.tername( dest ) );
11430 }
11431 }
11432 coming_to_stairs.erase( coming_to_stairs.begin() + i );
11433 continue;
11434 } else if( u.pos() == dest ) {
11435 // Monster attempts to push player of stairs
11437 int tries = 0;
11438
11439 // the critter is now right on top of you and will attack unless
11440 // it can find a square to push you into with one of his tries.
11441 const int creature_push_attempts = 9;
11442 const int player_throw_resist_chance = 3;
11443
11444 critter.spawn( dest );
11445 while( tries < creature_push_attempts ) {
11446 tries++;
11447 push.x = rng( -1, 1 );
11448 push.y = rng( -1, 1 );
11449 point ipos( mpos + push );
11450 tripoint pos( ipos, get_levz() );
11451 if( ( push.x != 0 || push.y != 0 ) && !critter_at( pos ) &&
11452 critter.can_move_to( pos ) ) {
11453 bool resiststhrow = ( u.is_throw_immune() ) ||
11455 if( resiststhrow && one_in( player_throw_resist_chance ) ) {
11456 u.moves -= 25; // small charge for avoiding the push altogether
11457 add_msg( _( "The %s fails to push you back!" ),
11458 critter.name() );
11459 return; //judo or leg brace prevent you from getting pushed at all
11460 }
11461 // Not accounting for tentacles latching on, so..
11462 // Something is about to happen, lets charge half a move
11463 u.moves -= 50;
11464 if( resiststhrow && ( u.is_throw_immune() ) ) {
11465 //we have a judoka who isn't getting pushed but counterattacking now.
11466 mattack::thrown_by_judo( &critter );
11467 return;
11468 }
11469 std::string msg;
11470 ///\EFFECT_DODGE reduces chance of being downed when pushed off the stairs
11471 if( !( resiststhrow ) && ( u.get_dodge() + rng( 0, 3 ) < 12 ) ) {
11472 // dodge 12 - never get downed
11473 // 11.. avoid 75%; 10.. avoid 50%; 9.. avoid 25%
11474 u.add_effect( effect_downed, 2_turns );
11475 msg = _( "The %s pushed you back hard!" );
11476 } else {
11477 msg = _( "The %s pushed you back!" );
11478 }
11479 add_msg( m_warning, msg.c_str(), critter.name() );
11480 u.setx( u.posx() + push.x );
11481 u.sety( u.posy() + push.y );
11482 return;
11483 }
11484 }
11486 _( "The %s tried to push you back but failed! It attacks you!" ),
11487 critter.name() );
11488 critter.melee_attack( u );
11489 u.moves -= 50;
11490 return;
11491 } else if( monster *const mon_ptr = critter_at<monster>( dest ) ) {
11492 // Monster attempts to displace a monster from the stairs
11493 monster &other = *mon_ptr;
11494 critter.spawn( dest );
11495
11496 // the critter is now right on top of another and will push it
11497 // if it can find a square to push it into inside of his tries.
11498 const int creature_push_attempts = 9;
11499 const int creature_throw_resist = 4;
11500
11501 int tries = 0;
11502 point push2;
11503 while( tries < creature_push_attempts ) {
11504 tries++;
11505 push2.x = rng( -1, 1 );
11506 push2.y = rng( -1, 1 );
11507 point ipos2( mpos + push2 );
11508 tripoint pos( ipos2, get_levz() );
11509 if( ( push2.x == 0 && push2.y == 0 ) || ( ( ipos2.x == u.posx() ) && ( ipos2.y == u.posy() ) ) ) {
11510 continue;
11511 }
11512 if( !critter_at( pos ) && other.can_move_to( pos ) ) {
11513 other.setpos( tripoint( ipos2, get_levz() ) );
11514 other.moves -= 50;
11515 std::string msg;
11516 if( one_in( creature_throw_resist ) ) {
11517 other.add_effect( effect_downed, 2_turns );
11518 msg = _( "The %1$s pushed the %2$s hard." );
11519 } else {
11520 msg = _( "The %1$s pushed the %2$s." );
11521 }
11522 add_msg( m_neutral, msg, critter.name(), other.name() );
11523 return;
11524 }
11525 }
11526 return;
11527 }
11528 }
11529}
void setx(int x)
Definition: character.h:847
void sety(int y)
Definition: character.h:850
bool is_throw_immune() const
Returns true if the player is immune to throws.
float get_dodge() const override
Definition: melee.cpp:782
int monstairz
Definition: game.h:1032
tripoint_range< tripoint > points_on_zlevel() const
Yields a range of all points that are contained in the map and have the z-level of this map (abs_sub)...
Definition: map.cpp:8448
bool can_move_to(const tripoint &p) const
Checks whether we can move to/through p.
Definition: monmove.cpp:249
int posy() const override
Definition: monster.h:498
void melee_attack(Creature &target)
Definition: monster.cpp:1370
int staircount
Definition: monster.h:509
void spawn(const tripoint &p)
Definition: monster.cpp:481
int posx() const override
Definition: monster.h:495
bool thrown_by_judo(monster *z)
Definition: monattack.cpp:4581
std::enable_if<!is_std_array< C >::value, constV & >::type random_entry_ref(const C &container)
Same as above, but with a statically allocated default value (using the default constructor).
Definition: rng.h:149

References _, Creature::add_effect(), add_msg(), monster::can_move_to(), coming_to_stairs, critter_at(), debugmsg, effect_downed, g, Character::get_dodge(), get_levz(), map::has_flag(), Character::has_trait(), map::has_zlevels(), is_empty(), Character::is_throw_immune(), m, m_neutral, m_warning, MAPSIZE_X, MAPSIZE_Y, monster::melee_attack(), monstairz, sounds::movement, Creature::moves, monster::name(), one_in(), other, place_critter_at(), point_north_west, map::points_on_zlevel(), Character::pos(), Character::posx(), monster::posx(), Character::posy(), monster::posy(), Character::posz(), monexamine::push(), random_entry_ref(), rl_dist(), rng(), Character::sees(), Character::setx(), Character::sety(), sounds::sound(), monster::spawn(), monster::staircount, string_format(), map::tername(), mattack::thrown_by_judo(), trait_LEG_TENT_BRACE, u, point::x, and point::y.

Referenced by do_turn(), and vertical_move().

◆ update_zombie_pos()

bool game::update_zombie_pos ( const monster critter,
const tripoint pos 
)

Redirects to the creature_tracker update_pos() function.

Definition at line 5020 of file game.cpp.

5021{
5022 return critter_tracker->update_pos( critter, pos );
5023}

References critter_tracker.

◆ use_computer()

void game::use_computer ( const tripoint p)

Checks to see if a player can use a computer (not illiterate, etc.) and uses if able.

Definition at line 4803 of file game.cpp.

4804{
4805 if( u.has_trait( trait_id( "ILLITERATE" ) ) ) {
4806 add_msg( m_info, _( "You can not read a computer screen!" ) );
4807 return;
4808 }
4809 if( u.is_blind() ) {
4810 // we don't have screen readers in game
4811 add_msg( m_info, _( "You can not see a computer screen!" ) );
4812 return;
4813 }
4814 if( u.has_trait( trait_id( "HYPEROPIC" ) ) && !u.worn_with_flag( "FIX_FARSIGHT" ) &&
4815 !u.has_effect( effect_contacts ) && !u.has_bionic( bionic_id( "bio_eye_optic" ) ) ) {
4816 add_msg( m_info, _( "You'll need to put on reading glasses before you can see the screen." ) );
4817 return;
4818 }
4819
4820 computer *used = m.computer_at( p );
4821
4822 if( used == nullptr ) {
4823 if( m.has_flag( "CONSOLE", p ) ) { //Console without map data
4824 add_msg( m_bad, _( "The console doesn't display anything coherent." ) );
4825 } else {
4826 debugmsg( "Tried to use computer at %s - none there", p.to_string() );
4827 }
4828 return;
4829 }
4830
4831 computer_session( *used ).use();
4832}
void use()
Handles player use of a computer.
computer * computer_at(const tripoint &p)
Definition: map.cpp:5525
static const efftype_id effect_contacts("contacts")

References _, add_msg(), map::computer_at(), debugmsg, effect_contacts, Character::has_bionic(), Creature::has_effect(), map::has_flag(), Character::has_trait(), Character::is_blind(), m, m_bad, m_info, tripoint::to_string(), u, computer_session::use(), and Character::worn_with_flag().

Referenced by examine().

◆ validate_camps()

void game::validate_camps ( )

validate camps to ensure they are on the overmap list

Definition at line 2036 of file game.cpp.

2037{
2038 basecamp camp = m.hoist_submap_camp( u.pos() );
2039 if( camp.is_valid() ) {
2040 overmap_buffer.add_camp( camp );
2042 } else if( camp.camp_omt_pos() != tripoint_abs_omt() ) {
2043 std::string camp_name = _( "Faction Camp" );
2044 camp.set_name( camp_name );
2045 overmap_buffer.add_camp( camp );
2047 }
2048}
bool is_valid() const
Definition: basecamp.h:125
void set_name(const std::string &new_name)
Definition: basecamp.cpp:575
tripoint_abs_omt camp_omt_pos() const
Definition: basecamp.h:134
basecamp hoist_submap_camp(const tripoint &p)
Definition: map.cpp:5556
void remove_submap_camp(const tripoint &)
Definition: map.cpp:5551
void add_camp(const basecamp &camp)
Add Basecamp to overmapbuffer.

References _, overmapbuffer::add_camp(), basecamp::camp_omt_pos(), map::hoist_submap_camp(), basecamp::is_valid(), m, overmap_buffer, Character::pos(), map::remove_submap_camp(), basecamp::set_name(), and u.

Referenced by load().

◆ validate_linked_vehicles()

void game::validate_linked_vehicles ( )

validate towed vehicles so they get linked up again after a load

Definition at line 1978 of file game.cpp.

1979{
1980 for( auto &veh : m.get_vehicles() ) {
1981 vehicle *v = veh.v;
1984 if( other_v ) {
1985 // the other vehicle is towing us.
1986 v->tow_data.set_towing( other_v, v );
1988 }
1989 }
1990 }
1991}
tripoint other_towing_point
Definition: vehicle.h:167
bool set_towing(vehicle *tower_veh, vehicle *towed_veh)
Definition: vehicle.cpp:5940
towing_data tow_data
Definition: vehicle.h:1925

References map::get_vehicles(), m, towing_data::other_towing_point, towing_data::set_towing(), vehicle::tow_data, tripoint_zero, map::veh_at(), and veh_pointer_or_null().

Referenced by load().

◆ validate_mounted_npcs()

void game::validate_mounted_npcs ( )

Definition at line 1993 of file game.cpp.

1994{
1995 for( monster &m : all_monsters() ) {
1996 if( m.has_effect( effect_ridden ) && m.mounted_player_id.is_valid() ) {
1997 player *mounted_pl = g->critter_by_id<player>( m.mounted_player_id );
1998 if( !mounted_pl ) {
1999 // Target no longer valid.
2000 m.mounted_player_id = character_id();
2001 m.remove_effect( effect_ridden );
2002 continue;
2003 }
2004 mounted_pl->mounted_creature = shared_from( m );
2005 mounted_pl->setpos( m.pos() );
2006 mounted_pl->add_effect( effect_riding, 1_turns, num_bp );
2007 m.mounted_player = mounted_pl;
2008 }
2009 }
2010}

References Creature::add_effect(), all_monsters(), character_id, effect_ridden, effect_riding, g, m, Character::mounted_creature, num_bp, Character::setpos(), and shared_from().

Referenced by load(), and vertical_shift().

◆ validate_npc_followers()

void game::validate_npc_followers ( )

validate list of followers to account for overmap buffers

Definition at line 2012 of file game.cpp.

2013{
2014 // Make sure visible followers are in the list.
2015 const std::vector<npc *> visible_followers = get_npcs_if( [&]( const npc & guy ) {
2016 return guy.is_player_ally();
2017 } );
2018 for( npc *guy : visible_followers ) {
2019 update_faction_api( guy );
2020 add_npc_follower( guy->getID() );
2021 }
2022 // Make sure overmapbuffered NPC followers are in the list.
2023 for( const auto &temp_guy : overmap_buffer.get_npcs_near_player( 300 ) ) {
2024 npc *guy = temp_guy.get();
2025 if( guy->is_player_ally() ) {
2026 update_faction_api( guy );
2027 add_npc_follower( guy->getID() );
2028 }
2029 }
2030 // Make sure that serialized player followers sync up with game list
2031 for( const auto &temp_id : u.follower_ids ) {
2032 add_npc_follower( temp_id );
2033 }
2034}
void add_npc_follower(const character_id &id)
Add follower id to set of followers.
Definition: game.cpp:1958
static void update_faction_api(npc *guy)
Definition: game.cpp:1970

References add_npc_follower(), player::follower_ids, get_npcs_if(), overmapbuffer::get_npcs_near_player(), Character::getID(), npc::is_player_ally(), overmap_buffer, u, and update_faction_api().

Referenced by load().

◆ vertical_move()

void game::vertical_move ( int  z,
bool  force,
bool  peeking = false 
)

Moves the player vertically.

If force == true then they are falling. If peeking == true, forbids some exotic movement options

Strength increases breath-holding capacity while diving Dexterity increases chance of moving past monsters on stairs Dodge increases chance of moving past monsters on stairs Strength increases chance of moving past monsters on stairs Melee increases chance of moving past monsters on stairs

Definition at line 10496 of file game.cpp.

10497{
10498 if( u.is_mounted() ) {
10499 auto mons = u.mounted_creature.get();
10500 if( mons->has_flag( MF_RIDEABLE_MECH ) ) {
10501 if( !mons->check_mech_powered() ) {
10502 add_msg( m_bad, _( "Your %s refuses to move as its batteries have been drained." ),
10503 mons->get_name() );
10504 return;
10505 }
10506 }
10507 }
10508
10509 // > and < are used for diving underwater.
10510 if( m.has_flag( "SWIMMABLE", u.pos() ) && m.has_flag( TFLAG_DEEP_WATER, u.pos() ) ) {
10511 if( movez == -1 ) {
10512 if( u.is_underwater() ) {
10513 add_msg( m_info, _( "You are already underwater!" ) );
10514 return;
10515 }
10516 if( u.worn_with_flag( "FLOTATION" ) ) {
10517 add_msg( m_info, _( "You can't dive while wearing a flotation device." ) );
10518 return;
10519 }
10520 u.set_underwater( true );
10521 ///\EFFECT_STR increases breath-holding capacity while diving
10522 u.oxygen = 30 + 2 * u.str_cur;
10523 add_msg( _( "You dive underwater!" ) );
10524 } else {
10525 if( u.swim_speed() < 500 || u.shoe_type_count( itype_swim_fins ) ) {
10526 u.set_underwater( false );
10527 add_msg( _( "You surface." ) );
10528 } else {
10529 add_msg( m_info, _( "You try to surface but can't!" ) );
10530 }
10531 }
10532 u.moves -= 100;
10533 return;
10534 }
10535
10536 // Force means we're going down, even if there's no staircase, etc.
10537 bool climbing = false;
10538 int move_cost = 100;
10539 tripoint stairs( u.posx(), u.posy(), u.posz() + movez );
10540 if( m.has_zlevels() && !force && movez == 1 && !m.has_flag( "GOES_UP", u.pos() ) ) {
10541 // Climbing
10542 if( m.has_floor_or_support( stairs ) ) {
10543 add_msg( m_info, _( "You can't climb here - there's a ceiling above your head." ) );
10544 return;
10545 }
10546
10547 std::vector<tripoint> pts;
10548 for( const auto &pt : m.points_in_radius( stairs, 1 ) ) {
10549 if( m.passable( pt ) &&
10550 m.has_floor_or_support( pt ) ) {
10551 pts.push_back( pt );
10552 }
10553 }
10554
10555 const int cost = u.climbing_cost( u.pos(), stairs );
10556
10557 if( cost == 0 ) {
10558 if( u.has_trait( trait_WEB_ROPE ) ) {
10559 if( pts.empty() ) {
10560 add_msg( m_info, _( "There is nothing above you that you can attach a web to." ) );
10561 } else if( can_use_mutation_warn( trait_WEB_ROPE, u ) ) {
10562 if( g->m.move_cost( u.pos() ) != 2 && g->m.move_cost( u.pos() ) != 3 ) {
10563 add_msg( m_info, _( "You can't spin a web rope there." ) );
10564 } else if( g->m.has_furn( u.pos() ) ) {
10565 add_msg( m_info, _( "There is already furniture at that location." ) );
10566 } else {
10567 if( query_yn( "Spin a rope and climb?" ) ) {
10568 add_msg( m_good, _( "You spin a rope of web." ) );
10569 g->m.furn_set( u.pos(), furn_str_id( "f_rope_up_web" ) );
10570 u.mod_moves( to_turns<int>( 2_seconds ) );
10572 vertical_move( movez, force, peeking );
10573 }
10574 }
10575 }
10576
10577 } else {
10578 add_msg( m_info, _( "You can't climb here - you need walls and/or furniture to brace against." ) );
10579
10580 }
10581 return;
10582
10583 }
10584
10585 if( cost <= 0 || pts.empty() ) {
10586 add_msg( m_info,
10587 _( "You can't climb here - there is no terrain above you that would support your weight." ) );
10588 return;
10589 } else {
10590 // TODO: Make it an extended action
10591 climbing = true;
10592 move_cost = cost;
10593
10595 if( !pnt ) {
10596 return;
10597 }
10598 stairs = *pnt;
10599 }
10600 }
10601
10602 if( !force && movez == -1 && !m.has_flag( "GOES_DOWN", u.pos() ) ) {
10603 add_msg( m_info, _( "You can't go down here!" ) );
10604 return;
10605 } else if( !climbing && !force && movez == 1 && !m.has_flag( "GOES_UP", u.pos() ) ) {
10606 add_msg( m_info, _( "You can't go up here!" ) );
10607 return;
10608 }
10609
10610 if( force ) {
10611 // Let go of a grabbed cart.
10612 u.grab( OBJECT_NONE );
10613 } else if( u.grab_point != tripoint_zero ) {
10614 add_msg( m_info, _( "You can't drag things up and down stairs." ) );
10615 return;
10616 }
10617
10618 // Because get_levz takes z-value from the map, it will change when vertical_shift (m.has_zlevels() == true)
10619 // is called or when the map is loaded on new z-level (== false).
10620 // This caches the z-level we start the movement on (current) and the level we're want to end.
10621 const int z_before = get_levz();
10622 const int z_after = get_levz() + movez;
10623 if( z_after < -OVERMAP_DEPTH || z_after > OVERMAP_HEIGHT ) {
10624 debugmsg( "Tried to move outside allowed range of z-levels" );
10625 return;
10626 }
10627
10628 if( !u.move_effects( false ) ) {
10629 return;
10630 }
10631
10632 // Check if there are monsters are using the stairs.
10633 bool slippedpast = false;
10634 if( !m.has_zlevels() && !coming_to_stairs.empty() && !force ) {
10635 // TODO: Allow travel if zombie couldn't reach stairs, but spawn him when we go up.
10636 add_msg( m_warning, _( "You try to use the stairs. Suddenly you are blocked by a %s!" ),
10637 coming_to_stairs[0].name() );
10638 // Roll.
10639 ///\EFFECT_DEX increases chance of moving past monsters on stairs
10640
10641 ///\EFFECT_DODGE increases chance of moving past monsters on stairs
10642 int dexroll = dice( 6, u.dex_cur + u.get_skill_level( skill_dodge ) * 2 );
10643 ///\EFFECT_STR increases chance of moving past monsters on stairs
10644
10645 ///\EFFECT_MELEE increases chance of moving past monsters on stairs
10646 int strroll = dice( 3, u.str_cur + u.get_skill_level( skill_melee ) * 1.5 );
10647 if( coming_to_stairs.size() > 4 ) {
10648 add_msg( _( "The are a lot of them on the %s!" ), m.tername( u.pos() ) );
10649 dexroll /= 4;
10650 strroll /= 2;
10651 } else if( coming_to_stairs.size() > 1 ) {
10652 add_msg( m_warning, _( "There's something else behind it!" ) );
10653 dexroll /= 2;
10654 }
10655
10656 if( dexroll < 14 || strroll < 12 ) {
10658 u.moves -= 100;
10659 return;
10660 }
10661
10662 add_msg( _( "You manage to slip past!" ) );
10663 slippedpast = true;
10664 u.moves -= 100;
10665 }
10666
10667 // Shift the map up or down
10668
10669 std::unique_ptr<map> tmp_map_ptr;
10670 if( !m.has_zlevels() ) {
10671 tmp_map_ptr = std::make_unique<map>();
10672 }
10673
10674 map &maybetmp = m.has_zlevels() ? m : *( tmp_map_ptr.get() );
10675 if( m.has_zlevels() ) {
10676 // We no longer need to shift the map here! What joy
10677 } else {
10678 maybetmp.load( tripoint( get_levx(), get_levy(), z_after ), false );
10679 }
10680
10681 // Find the corresponding staircase
10682 bool rope_ladder = false;
10683 // TODO: Remove the stairfinding, make the mapgen gen aligned maps
10684 if( !force && !climbing ) {
10685 const cata::optional<tripoint> pnt = find_or_make_stairs( maybetmp, z_after, rope_ladder, peeking );
10686 if( !pnt ) {
10687 return;
10688 }
10689 stairs = *pnt;
10690 }
10691
10692 if( !force ) {
10693 monstairz = z_before;
10694 }
10695 // Save all monsters that can reach the stairs, remove them from the tracker,
10696 // then despawn the remaining monsters. Because it's a vertical shift, all
10697 // monsters are out of the bounds of the map and will despawn.
10698 shared_ptr_fast<monster> stored_mount;
10699 if( u.is_mounted() && !m.has_zlevels() ) {
10700 // Store a *copy* of the mount, so we can remove the original monster instance
10701 // from the tracker before the map shifts.
10702 // Map shifting would otherwise just despawn the mount and would later respawn it.
10703 stored_mount = make_shared_fast<monster>( *u.mounted_creature );
10705 }
10706 if( !m.has_zlevels() ) {
10707 const tripoint to = u.pos();
10708 for( monster &critter : all_monsters() ) {
10709 // if its a ladder instead of stairs - most zombies can't climb that.
10710 // unless that have a special flag to allow them to do so.
10711 if( ( m.has_flag( "DIFFICULT_Z", u.pos() ) && !critter.climbs() ) ||
10712 critter.has_effect( effect_ridden ) ||
10713 critter.has_effect( effect_tied ) ) {
10714 continue;
10715 }
10716 int turns = critter.turns_to_reach( to.xy() );
10717 if( turns < 10 && coming_to_stairs.size() < 8 && critter.will_reach( to.xy() )
10718 && !slippedpast ) {
10719 critter.staircount = 10 + turns;
10720 critter.on_unload();
10721 coming_to_stairs.push_back( critter );
10722 remove_zombie( critter );
10723 }
10724 }
10725 auto mons = critter_tracker->find( g->u.pos() );
10726 if( mons != nullptr ) {
10727 critter_tracker->remove( *mons );
10728 }
10729 shift_monsters( tripoint( 0, 0, movez ) );
10730 }
10731
10732 std::vector<shared_ptr_fast<npc>> npcs_to_bring;
10733 std::vector<monster *> monsters_following;
10734 if( !m.has_zlevels() && std::abs( movez ) == 1 ) {
10735 std::copy_if( active_npc.begin(), active_npc.end(), back_inserter( npcs_to_bring ),
10736 [this]( const shared_ptr_fast<npc> &np ) {
10737 return np->is_walking_with() && !np->is_mounted() && !np->in_sleep_state() &&
10738 rl_dist( np->pos(), u.pos() ) < 2;
10739 } );
10740 }
10741
10742 if( m.has_zlevels() && std::abs( movez ) == 1 ) {
10743 bool ladder = m.has_flag( "DIFFICULT_Z", u.pos() );
10744 for( monster &critter : all_monsters() ) {
10745 if( ladder && !critter.climbs() ) {
10746 continue;
10747 }
10748 if( critter.attack_target() == &g->u || ( !critter.has_effect( effect_ridden ) &&
10749 critter.has_effect( effect_pet ) && critter.friendly == -1 &&
10750 !critter.has_effect( effect_tied ) ) ) {
10751 monsters_following.push_back( &critter );
10752 }
10753 }
10754 }
10755
10756 if( u.is_mounted() ) {
10757 monster *crit = u.mounted_creature.get();
10758 if( crit->has_flag( MF_RIDEABLE_MECH ) ) {
10759 crit->use_mech_power( -1 );
10760 if( u.movement_mode_is( CMM_WALK ) ) {
10761 crit->use_mech_power( -2 );
10762 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
10763 crit->use_mech_power( -1 );
10764 } else if( u.movement_mode_is( CMM_RUN ) ) {
10765 crit->use_mech_power( -3 );
10766 }
10767 }
10768 } else {
10769 u.moves -= move_cost;
10770 }
10771 for( const auto &np : npcs_to_bring ) {
10772 if( np->in_vehicle ) {
10773 m.unboard_vehicle( np->pos() );
10774 }
10775 }
10776 const tripoint old_pos = g->u.pos();
10777 point submap_shift;
10778 vertical_shift( z_after );
10779 if( !force ) {
10780 submap_shift = update_map( stairs.x, stairs.y );
10781 }
10782
10783 // if an NPC or monster is on the stiars when player ascends/descends
10784 // they may end up merged on th esame tile, do some displacement to resolve that.
10785 // if, in the weird case of it not being possible to displace;
10786 // ( how did the player even manage to approach the stairs, if so? )
10787 // then nothing terrible happens, its just weird.
10788 if( critter_at<npc>( u.pos(), true ) || critter_at<monster>( u.pos(), true ) ) {
10789 std::string crit_name;
10790 bool player_displace = false;
10792 if( displace.has_value() ) {
10793 npc *guy = g->critter_at<npc>( u.pos(), true );
10794 if( guy ) {
10795 crit_name = guy->get_name();
10796 tripoint old_pos = guy->pos();
10797 if( !guy->is_enemy() ) {
10798 guy->move_away_from( u.pos(), true );
10799 if( old_pos != guy->pos() ) {
10800 add_msg( _( "%s moves out of the way for you." ), guy->get_name() );
10801 }
10802 } else {
10803 player_displace = true;
10804 }
10805 }
10806 monster *mon = g->critter_at<monster>( u.pos(), true );
10807 // if the monster is ridden by the player or an NPC:
10808 // Dont displace them. If they are mounted by a friendly NPC,
10809 // then the NPC will already have been displaced just above.
10810 // if they are ridden by the player, we want them to coexist on same tile
10811 if( mon && !mon->mounted_player ) {
10812 crit_name = mon->get_name();
10813 if( mon->friendly == -1 ) {
10814 mon->setpos( *displace );
10815 add_msg( _( "Your %s moves out of the way for you." ), mon->get_name() );
10816 } else {
10817 player_displace = true;
10818 }
10819 }
10820 if( player_displace ) {
10821 u.setpos( *displace );
10822 u.moves -= 20;
10823 add_msg( _( "You push past %s blocking the way." ), crit_name );
10824 }
10825 } else {
10826 debugmsg( "Failed to find a spot to displace into." );
10827 }
10828 }
10829
10830 // Now that we know the player's destination position, we can move their mount as well
10831 if( u.is_mounted() ) {
10832 if( stored_mount ) {
10833 assert( !m.has_zlevels() );
10834 stored_mount->spawn( g->u.pos() );
10835 if( critter_tracker->add( stored_mount ) ) {
10836 u.mounted_creature = stored_mount;
10837 }
10838 } else {
10839 u.mounted_creature->setpos( g->u.pos() );
10840 }
10841 }
10842
10843 if( !npcs_to_bring.empty() ) {
10844 // Would look nicer randomly scrambled
10845 std::vector<tripoint> candidates = closest_points_first( u.pos(), 1 );
10846 candidates.erase( std::remove_if( candidates.begin(), candidates.end(),
10847 [this]( const tripoint & c ) {
10848 return !is_empty( c );
10849 } ), candidates.end() );
10850
10851 for( const auto &np : npcs_to_bring ) {
10852 const auto found = std::find_if( candidates.begin(), candidates.end(),
10853 [this, np]( const tripoint & c ) {
10854 return !np->is_dangerous_fields( m.field_at( c ) ) && m.tr_at( c ).is_benign();
10855 } );
10856 if( found != candidates.end() ) {
10857 // TODO: De-uglify
10858 np->setpos( *found );
10859 np->place_on_map();
10860 np->setpos( *found );
10861 candidates.erase( found );
10862 }
10863
10864 if( candidates.empty() ) {
10865 break;
10866 }
10867 }
10868
10869 reload_npcs();
10870 }
10871
10872 // This ugly check is here because of stair teleport bullshit
10873 // TODO: Remove stair teleport bullshit
10874 if( rl_dist( g->u.pos(), old_pos ) <= 1 ) {
10875 for( monster *m : monsters_following ) {
10876 m->set_dest( g->u.pos() );
10877 }
10878 }
10879
10880 if( rope_ladder ) {
10881 m.ter_set( u.pos(), t_rope_up );
10882 }
10883
10884 if( m.ter( stairs ) == t_manhole_cover ) {
10885 m.spawn_item( stairs + point( rng( -1, 1 ), rng( -1, 1 ) ), itype_manhole_cover );
10886 m.ter_set( stairs, t_manhole );
10887 }
10888
10889 // Wouldn't work and may do strange things
10890 if( u.is_hauling() && !m.has_zlevels() ) {
10891 add_msg( _( "You cannot haul items here." ) );
10892 u.stop_hauling();
10893 }
10894
10895 if( u.is_hauling() ) {
10896 const tripoint adjusted_pos = old_pos - sm_to_ms_copy( submap_shift );
10897 start_hauling( adjusted_pos );
10898 }
10899
10900 m.invalidate_map_cache( g->get_levz() );
10901 // Upon force movement, traps can not be avoided.
10902 m.creature_on_trap( u, !force );
10903
10905}
static int move_cost(const item &it, const tripoint &src, const tripoint &dest)
@ CMM_WALK
Definition: character.h:97
@ CMM_CROUCH
Definition: character.h:99
bool move_effects(bool attacking) override
Processes effects which may prevent the Character from moving (bear traps, crushed,...
Definition: character.cpp:1531
int swim_speed() const
Returns the player's speed for swimming across water tiles.
Definition: character.cpp:875
int oxygen
Definition: character.h:1594
void mutation_spend_resources(const trait_id &mut)
Removes the appropriate costs (NOTE: will reapply mods & recalc sightlines in case of newly activated...
Definition: mutation.cpp:1723
int shoe_type_count(const itype_id &it) const
Returns 1 if the player is wearing an item of that count on one foot, 2 if on both,...
Definition: character.cpp:8938
std::string get_name() const override
Definition: character.cpp:6087
void start_hauling(const tripoint &pos)
Definition: game.cpp:10907
cata::optional< tripoint > find_or_make_stairs(map &mp, int z_after, bool &rope_ladder, bool peeking)
Returns the other end of the stairs (if any).
Definition: game.cpp:10942
bool use_mech_power(int amt)
Definition: monster.cpp:2368
Character * mounted_player
Definition: monster.h:458
int climbing_cost(const tripoint &from, const tripoint &to) const
Checks both the neighborhoods of from and to for climbable surfaces, returns move cost of climbing fr...
Definition: player.cpp:4330
void set_underwater(bool)
Definition: player.cpp:588
static const efftype_id effect_tied("tied")
static const itype_id itype_manhole_cover("manhole_cover")
static const skill_id skill_melee("melee")
static cata::optional< tripoint > point_selection_menu(const std::vector< tripoint > &pts)
Definition: game.cpp:10446
static const itype_id itype_swim_fins("swim_fins")
static const trait_id trait_WEB_ROPE("WEB_ROPE")
ter_id t_rope_up
Definition: mapdata.cpp:719
ter_id t_manhole
Definition: mapdata.cpp:718
bool can_use_mutation_warn(const trait_id &mut, const Character &character)
Calls can_use_mutation and if it fails, print a standard message.
Definition: mutation.cpp:1712
void avatar_moves(const avatar &u, const map &m, const tripoint &p)
Definition: game.cpp:12565
int ladder(player *, item *, bool, const tripoint &)
Definition: iuse.cpp:9445
point displace(type dir, int dist=1)
Returns point(0, 0) displaced in specified direction by a specified distance.
Definition: overmap.cpp:4159

References _, active_npc, add_msg(), all_monsters(), cata_event_dispatch::avatar_moves(), c, can_use_mutation_warn(), player::climbing_cost(), closest_points_first(), CMM_CROUCH, CMM_RUN, CMM_WALK, coming_to_stairs, map::creature_on_trap(), critter_tracker, debugmsg, Character::dex_cur, dice(), om_direction::displace(), effect_pet, effect_ridden, effect_tied, find_empty_spot_nearby(), find_or_make_stairs(), monster::friendly, g, get_levx(), get_levy(), get_levz(), Character::get_name(), monster::get_name(), Character::get_skill_level(), avatar::grab(), player::grab_point, map::has_flag(), monster::has_flag(), map::has_floor_or_support(), Character::has_trait(), map::has_zlevels(), map::invalidate_map_cache(), npc::is_enemy(), Character::is_hauling(), Character::is_mounted(), Creature::is_underwater(), itype_manhole_cover, itype_swim_fins, iuse::ladder(), map::load(), m, m_bad, m_good, m_info, m_warning, MF_RIDEABLE_MECH, Creature::mod_moves(), monstairz, Character::mounted_creature, monster::mounted_player, npc::move_away_from(), move_cost(), Character::move_effects(), Character::movement_mode_is(), Creature::moves, Character::mutation_spend_resources(), om_direction::name(), OBJECT_NONE, OVERMAP_HEIGHT, Character::oxygen, map::passable(), point_selection_menu(), map::points_in_radius(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), query_yn(), reload_npcs(), remove_zombie(), rl_dist(), rng(), player::set_underwater(), Character::setpos(), monster::setpos(), shift_monsters(), Character::shoe_type_count(), skill_dodge, skill_melee, sm_to_ms_copy(), map::spawn_item(), start_hauling(), Character::stop_hauling(), Character::str_cur, Character::swim_speed(), t_manhole, t_manhole_cover, t_rope_up, map::ter(), map::ter_set(), map::tername(), TFLAG_DEEP_WATER, trait_WEB_ROPE, tripoint_zero, u, map::unboard_vehicle(), update_map(), update_stair_monsters(), monster::use_mech_power(), vertical_move(), vertical_shift(), Character::worn_with_flag(), tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by handle_action(), peek(), and vertical_move().

◆ vertical_notes()

void game::vertical_notes ( int  z_before,
int  z_after 
)

Add goes up/down auto_notes (if turned on)

Definition at line 11129 of file game.cpp.

11130{
11131 if( z_before == z_after || !get_option<bool>( "AUTO_NOTES" ) ||
11132 !get_option<bool>( "AUTO_NOTES_STAIRS" ) ) {
11133 return;
11134 }
11135
11136 if( !m.inbounds_z( z_before ) || !m.inbounds_z( z_after ) ) {
11137 debugmsg( "game::vertical_notes invalid arguments: z_before == %d, z_after == %d",
11138 z_before, z_after );
11139 return;
11140 }
11141 // Figure out where we know there are up/down connectors
11142 // Fill in all the tiles we know about (e.g. subway stations)
11143 static const int REVEAL_RADIUS = 40;
11144 for( const tripoint_abs_omt &p : points_in_radius( u.global_omt_location(), REVEAL_RADIUS ) ) {
11145 const tripoint_abs_omt cursp_before( p.xy(), z_before );
11146 const tripoint_abs_omt cursp_after( p.xy(), z_after );
11147
11148 if( !overmap_buffer.seen( cursp_before ) ) {
11149 continue;
11150 }
11151 if( overmap_buffer.has_note( cursp_after ) ) {
11152 // Already has a note -> never add an AUTO-note
11153 continue;
11154 }
11155 const oter_id &ter = overmap_buffer.ter( cursp_before );
11156 const oter_id &ter2 = overmap_buffer.ter( cursp_after );
11157 if( z_after > z_before && ter->has_flag( known_up ) &&
11158 !ter2->has_flag( known_down ) ) {
11159 overmap_buffer.set_seen( cursp_after, true );
11160 overmap_buffer.add_note( cursp_after, string_format( ">:W;%s", _( "AUTO: goes down" ) ) );
11161 } else if( z_after < z_before && ter->has_flag( known_down ) &&
11162 !ter2->has_flag( known_up ) ) {
11163 overmap_buffer.set_seen( cursp_after, true );
11164 overmap_buffer.add_note( cursp_after, string_format( "<:W;%s", _( "AUTO: goes up" ) ) );
11165 }
11166 }
11167}
bool inbounds_z(const int z) const
Definition: map.h:1643
void add_note(const tripoint_abs_omt &, const std::string &message)
@ known_up
Definition: omdata.h:91
@ known_down
Definition: omdata.h:90
bool has_flag(oter_flags flag) const
Definition: omdata.h:262

References _, overmapbuffer::add_note(), debugmsg, Character::global_omt_location(), oter_t::has_flag(), overmapbuffer::has_note(), map::inbounds_z(), known_down, known_up, m, overmap_buffer, points_in_radius(), overmapbuffer::seen(), overmapbuffer::set_seen(), string_format(), overmapbuffer::ter(), and u.

Referenced by vertical_shift().

◆ vertical_shift()

void game::vertical_shift ( int  z_after)

Actual z-level movement part of vertical_move.

Doesn't include stair finding, traps etc.

Definition at line 11092 of file game.cpp.

11093{
11094 if( z_after < -OVERMAP_DEPTH || z_after > OVERMAP_HEIGHT ) {
11095 debugmsg( "Tried to get z-level %d outside allowed range of %d-%d",
11096 z_after, -OVERMAP_DEPTH, OVERMAP_HEIGHT );
11097 return;
11098 }
11099
11100 // TODO: Implement dragging stuff up/down
11101 u.grab( OBJECT_NONE );
11102
11103 scent.reset();
11104
11105 u.setz( z_after );
11106 const int z_before = get_levz();
11107 if( !m.has_zlevels() ) {
11109 m.access_cache( z_before ).vehicle_list.clear();
11110 m.access_cache( z_before ).zone_vehicles.clear();
11111 m.access_cache( z_before ).map_memory_seen_cache.reset();
11112 m.set_transparency_cache_dirty( z_before );
11113 m.set_outside_cache_dirty( z_before );
11114 m.load( tripoint( get_levx(), get_levy(), z_after ), true );
11115 shift_monsters( tripoint( 0, 0, z_after - z_before ) );
11116 reload_npcs();
11117 } else {
11118 // Shift the map itself
11119 m.vertical_shift( z_after );
11120 }
11121
11122 m.spawn_monsters( true );
11123 // this may be required after a vertical shift if z-levels are not enabled
11124 // the critter is unloaded/loaded, and it needs to reconstruct its rider data after being reloaded.
11126 vertical_notes( z_before, z_after );
11127}
void setz(int z)
Definition: character.h:853
void vertical_notes(int z_before, int z_after)
Add goes up/down auto_notes (if turned on)
Definition: game.cpp:11129
void set_transparency_cache_dirty(const int zlev)
Sets a dirty flag on the a given cache.
Definition: map.h:393
void set_outside_cache_dirty(const int zlev)
Definition: map.h:430
void vertical_shift(int newz)
Moves the map vertically to (not by!) newz.
Definition: map.cpp:6772
std::set< vehicle * > zone_vehicles
Definition: map.h:346
std::set< vehicle * > vehicle_list
Definition: map.h:345

References map::access_cache(), map::clear_vehicle_cache(), debugmsg, get_levx(), get_levy(), get_levz(), avatar::grab(), map::has_zlevels(), map::load(), m, level_cache::map_memory_seen_cache, OBJECT_NONE, OVERMAP_DEPTH, OVERMAP_HEIGHT, reload_npcs(), scent_map::reset(), scent, map::set_outside_cache_dirty(), map::set_transparency_cache_dirty(), Character::setz(), shift_monsters(), map::spawn_monsters(), u, validate_mounted_npcs(), level_cache::vehicle_list, vertical_notes(), map::vertical_shift(), and level_cache::zone_vehicles.

Referenced by place_player(), and vertical_move().

◆ walk_move()

bool game::walk_move ( const tripoint dest,
bool  via_ramp = false 
)

TODO: This should really use the mounted creatures stamina, if mounted. Monsters don't currently have stamina however. For the time being just don't burn players stamina when mounted.

Dexterity decreases chance of tentacles getting stuck to the ground Intelligence decreases chance of tentacles getting stuck to the ground

Definition at line 9309 of file game.cpp.

9310{
9311 if( m.has_flag_ter( TFLAG_SMALL_PASSAGE, dest_loc ) ) {
9312 if( u.get_size() > MS_MEDIUM ) {
9313 add_msg( m_warning, _( "You can't fit there." ) );
9314 return false; // character too large to fit through a tight passage
9315 }
9316 if( u.is_mounted() ) {
9317 monster *mount = u.mounted_creature.get();
9318 if( mount->get_size() > MS_MEDIUM ) {
9319 add_msg( m_warning, _( "Your mount can't fit there." ) );
9320 return false; // char's mount is too large for tight passages
9321 }
9322 }
9323 }
9324
9325 if( u.is_mounted() ) {
9326 auto mons = u.mounted_creature.get();
9327 if( mons->has_flag( MF_RIDEABLE_MECH ) ) {
9328 if( !mons->check_mech_powered() ) {
9329 add_msg( m_bad, _( "Your %s refuses to move as its batteries have been drained." ),
9330 mons->get_name() );
9331 return false;
9332 }
9333 }
9334 if( !mons->move_effects( false ) ) {
9335 add_msg( m_bad, _( "You cannot move as your %s isn't able to move." ), mons->get_name() );
9336 return false;
9337 }
9338 }
9339 const optional_vpart_position vp_here = m.veh_at( u.pos() );
9340 const optional_vpart_position vp_there = m.veh_at( dest_loc );
9341
9342 bool pushing = false; // moving -into- grabbed tile; skip check for move_cost > 0
9343 bool pulling = false; // moving -away- from grabbed tile; check for move_cost > 0
9344 bool shifting_furniture = false; // moving furniture and staying still; skip check for move_cost > 0
9345
9346 const tripoint furn_pos = u.pos() + u.grab_point;
9347 const tripoint furn_dest = dest_loc + u.grab_point;
9348
9349 bool grabbed = u.get_grab_type() != OBJECT_NONE;
9350 if( grabbed ) {
9351 const tripoint dp = dest_loc - u.pos();
9352 pushing = dp == u.grab_point;
9353 pulling = dp == -u.grab_point;
9354 }
9355 if( grabbed && dest_loc.z != u.posz() ) {
9356 add_msg( m_warning, _( "You let go of the grabbed object." ) );
9357 grabbed = false;
9358 u.grab( OBJECT_NONE );
9359 }
9360
9361 // Now make sure we're actually holding something
9362 const vehicle *grabbed_vehicle = nullptr;
9363 if( grabbed && u.get_grab_type() == OBJECT_FURNITURE ) {
9364 // We only care about shifting, because it's the only one that can change our destination
9365 if( m.has_furn( u.pos() + u.grab_point ) ) {
9366 shifting_furniture = !pushing && !pulling;
9367 } else {
9368 // We were grabbing a furniture that isn't there
9369 grabbed = false;
9370 }
9371 } else if( grabbed && u.get_grab_type() == OBJECT_VEHICLE ) {
9372 grabbed_vehicle = veh_pointer_or_null( m.veh_at( u.pos() + u.grab_point ) );
9373 if( grabbed_vehicle == nullptr ) {
9374 // We were grabbing a vehicle that isn't there anymore
9375 grabbed = false;
9376 }
9377 } else if( grabbed ) {
9378 // We were grabbing something WEIRD, let's pretend we weren't
9379 grabbed = false;
9380 }
9381 if( u.grab_point != tripoint_zero && !grabbed ) {
9382 add_msg( m_warning, _( "Can't find grabbed object." ) );
9383 u.grab( OBJECT_NONE );
9384 }
9385
9386 if( m.impassable( dest_loc ) && !pushing && !shifting_furniture ) {
9387 if( vp_there && u.mounted_creature && u.mounted_creature->has_flag( MF_RIDEABLE_MECH ) &&
9388 vp_there->vehicle().handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
9389 tripoint diff = dest_loc - u.pos();
9390 if( diff.x < 0 ) {
9391 diff.x -= 2;
9392 } else if( diff.x > 0 ) {
9393 diff.x += 2;
9394 }
9395 if( diff.y < 0 ) {
9396 diff.y -= 2;
9397 } else if( diff.y > 0 ) {
9398 diff.y += 2;
9399 }
9400 u.mounted_creature->shove_vehicle( dest_loc + diff.xy(),
9401 dest_loc );
9402 }
9403 return false;
9404 }
9405 if( vp_there && !vp_there->vehicle().handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
9406 return false;
9407 }
9408 if( u.is_mounted() && !pushing && vp_there ) {
9409 add_msg( m_warning, _( "You cannot board a vehicle whilst riding." ) );
9410 return false;
9411 }
9412 u.set_underwater( false );
9413
9414 if( !shifting_furniture && !pushing && is_dangerous_tile( dest_loc ) ) {
9415 std::vector<std::string> harmful_stuff = get_dangerous_tile( dest_loc );
9416 if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "ALWAYS" &&
9417 !prompt_dangerous_tile( dest_loc ) ) {
9418 return true;
9419 } else if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "RUNNING" &&
9420 ( !u.movement_mode_is( CMM_RUN ) || !prompt_dangerous_tile( dest_loc ) ) ) {
9422 _( "Stepping into that %1$s looks risky. Run into it if you wish to enter anyway." ),
9423 enumerate_as_string( harmful_stuff ) );
9424 return true;
9425 } else if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "CROUCHING" &&
9426 ( !u.movement_mode_is( CMM_CROUCH ) || !prompt_dangerous_tile( dest_loc ) ) ) {
9428 _( "Stepping into that %1$s looks risky. Crouch and move into it if you wish to enter anyway." ),
9429 enumerate_as_string( harmful_stuff ) );
9430 return true;
9431 } else if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "NEVER" &&
9432 !u.movement_mode_is( CMM_RUN ) ) {
9434 _( "Stepping into that %1$s looks risky. Run into it if you wish to enter anyway." ),
9435 enumerate_as_string( harmful_stuff ) );
9436 return true;
9437 }
9438 }
9439 // Used to decide whether to print a 'moving is slow message
9440 const int mcost_from = m.move_cost( u.pos() ); //calculate this _before_ calling grabbed_move
9441
9442 int modifier = 0;
9443 if( grabbed && u.get_grab_type() == OBJECT_FURNITURE && u.pos() + u.grab_point == dest_loc ) {
9444 modifier = -m.furn( dest_loc ).obj().movecost;
9445 }
9446
9447 int multiplier = 1;
9448 if( u.is_on_ground() ) {
9449 multiplier *= 3;
9450 }
9451
9452 const int mcost = m.combined_movecost( u.pos(), dest_loc, grabbed_vehicle, modifier,
9453 via_ramp ) * multiplier;
9454 if( grabbed_move( dest_loc - u.pos() ) ) {
9455 return true;
9456 } else if( mcost == 0 ) {
9457 return false;
9458 }
9459 bool diag = trigdist && u.posx() != dest_loc.x && u.posy() != dest_loc.y;
9460 const int previous_moves = u.moves;
9461 if( u.is_mounted() ) {
9462 auto crit = u.mounted_creature.get();
9463 if( !crit->has_flag( MF_RIDEABLE_MECH ) &&
9464 ( m.has_flag_ter_or_furn( "MOUNTABLE", dest_loc ) ||
9465 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR", dest_loc ) ||
9466 m.has_flag_ter_or_furn( "OPENCLOSE_INSIDE", dest_loc ) ||
9467 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR_DAMAGED", dest_loc ) ||
9468 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR_REINFORCED", dest_loc ) ) ) {
9469 add_msg( m_warning, _( "You cannot pass obstacles whilst mounted." ) );
9470 return false;
9471 }
9472 const double base_moves = u.run_cost( mcost, diag ) * 100.0 / crit->get_speed();
9473 const double encumb_moves = u.get_weight() / 4800.0_gram;
9474 u.moves -= static_cast<int>( std::ceil( base_moves + encumb_moves ) );
9475 if( u.movement_mode_is( CMM_WALK ) ) {
9476 crit->use_mech_power( -2 );
9477 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
9478 crit->use_mech_power( -1 );
9479 } else if( u.movement_mode_is( CMM_RUN ) ) {
9480 crit->use_mech_power( -3 );
9481 }
9482 } else {
9483 u.moves -= u.run_cost( mcost, diag );
9484 /**
9485 TODO:
9486 This should really use the mounted creatures stamina, if mounted.
9487 Monsters don't currently have stamina however.
9488 For the time being just don't burn players stamina when mounted.
9489 */
9490 if( grabbed_vehicle == nullptr || grabbed_vehicle->wheelcache.empty() ) {
9491 //Burn normal amount of stamina if no vehicle grabbed or vehicle lacks wheels
9492 u.burn_move_stamina( previous_moves - u.moves );
9493 } else {
9494 //Burn half as much stamina if vehicle has wheels, without changing move time
9495 u.burn_move_stamina( 0.50 * ( previous_moves - u.moves ) );
9496 }
9497 }
9498 // Max out recoil & reset aim point
9501
9502 // Print a message if movement is slow
9503 const int mcost_to = m.move_cost( dest_loc ); //calculate this _after_ calling grabbed_move
9504 const bool fungus = m.has_flag_ter_or_furn( "FUNGUS", u.pos() ) ||
9505 m.has_flag_ter_or_furn( "FUNGUS",
9506 dest_loc ); //fungal furniture has no slowing effect on mycus characters
9507 const bool slowed = ( ( !u.has_trait( trait_PARKOUR ) && ( mcost_to > 2 || mcost_from > 2 ) ) ||
9508 mcost_to > 4 || mcost_from > 4 ) &&
9509 !( u.has_trait( trait_M_IMMUNE ) && fungus );
9510 if( slowed && !u.is_mounted() ) {
9511 // Unless u.pos() has a higher movecost than dest_loc, state that dest_loc is the cause
9512 if( mcost_to >= mcost_from ) {
9513 if( auto displayed_part = vp_there.part_displayed() ) {
9514 add_msg( m_warning, _( "Moving onto this %s is slow!" ),
9515 displayed_part->part().name() );
9516 sfx::do_obstacle( displayed_part->part().info().get_id().str() );
9517 } else {
9518 add_msg( m_warning, _( "Moving onto this %s is slow!" ), m.name( dest_loc ) );
9519 sfx::do_obstacle( m.ter( dest_loc ).id().str() );
9520 }
9521 } else {
9522 if( auto displayed_part = vp_here.part_displayed() ) {
9523 add_msg( m_warning, _( "Moving off of this %s is slow!" ),
9524 displayed_part->part().name() );
9525 sfx::do_obstacle( displayed_part->part().info().get_id().str() );
9526 } else {
9527 add_msg( m_warning, _( "Moving off of this %s is slow!" ), m.name( u.pos() ) );
9528 sfx::do_obstacle( m.ter( u.pos() ).id().str() );
9529 }
9530 }
9531 }
9532 if( !u.is_mounted() && u.has_trait( trait_id( "LEG_TENT_BRACE" ) ) &&
9533 ( !u.footwear_factor() ||
9534 ( u.footwear_factor() == .5 && one_in( 2 ) ) ) ) {
9535 // DX and IN are long suits for Cephalopods,
9536 // so this shouldn't cause too much hardship
9537 // Presumed that if it's swimmable, they're
9538 // swimming and won't stick
9539 ///\EFFECT_DEX decreases chance of tentacles getting stuck to the ground
9540
9541 ///\EFFECT_INT decreases chance of tentacles getting stuck to the ground
9542 if( !m.has_flag( "SWIMMABLE", dest_loc ) && one_in( 80 + u.dex_cur + u.int_cur ) ) {
9543 add_msg( _( "Your tentacles stick to the ground, but you pull them free." ) );
9544 u.mod_fatigue( 1 );
9545 }
9546 }
9547 if( !u.has_artifact_with( AEP_STEALTH ) && !u.has_trait( trait_id( "DEBUG_SILENT" ) ) ) {
9548 int volume = u.is_stealthy() ? 3 : 6;
9549 volume *= u.mutation_value( "noise_modifier" );
9550 if( volume > 0 ) {
9552 volume = 2;
9553 } else if( u.has_bionic( bionic_id( "bio_ankles" ) ) ) {
9554 volume = 12;
9555 }
9556 if( u.movement_mode_is( CMM_RUN ) ) {
9557 volume *= 1.5;
9558 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
9559 volume /= 2;
9560 }
9561 if( u.is_mounted() ) {
9562 auto mons = u.mounted_creature.get();
9563 switch( mons->get_size() ) {
9564 case MS_TINY:
9565 volume = 0; // No sound for the tinies
9566 break;
9567 case MS_SMALL:
9568 volume /= 3;
9569 break;
9570 case MS_MEDIUM:
9571 break;
9572 case MS_LARGE:
9573 volume *= 1.5;
9574 break;
9575 case MS_HUGE:
9576 volume *= 2;
9577 break;
9578 default:
9579 break;
9580 }
9581 if( mons->has_flag( MF_LOUDMOVES ) ) {
9582 volume += 6;
9583 }
9584 sounds::sound( dest_loc, volume, sounds::sound_t::movement, mons->type->get_footsteps(), false,
9585 "none", "none" );
9586 } else {
9587 sounds::sound( dest_loc, volume, sounds::sound_t::movement, _( "footsteps" ), true,
9588 "none", "none" ); // Sound of footsteps may awaken nearby monsters
9589 }
9591 }
9592
9593 if( one_in( 20 ) && u.has_artifact_with( AEP_MOVEMENT_NOISE ) ) {
9594 sounds::sound( u.pos(), 40, sounds::sound_t::movement, _( "a rattling sound." ), true,
9595 "misc", "rattling" );
9596 }
9597 }
9598
9599 if( m.has_flag_ter_or_furn( TFLAG_HIDE_PLACE, dest_loc ) ) {
9600 add_msg( m_good, _( "You are hiding in the %s." ), m.name( dest_loc ) );
9601 }
9602
9603 if( dest_loc != u.pos() ) {
9605 }
9606
9607 tripoint oldpos = u.pos();
9608 point submap_shift = place_player( dest_loc );
9609 point ms_shift = sm_to_ms_copy( submap_shift );
9610 oldpos = oldpos - ms_shift;
9611
9612 if( pulling ) {
9613 const tripoint shifted_furn_pos = furn_pos - ms_shift;
9614 const tripoint shifted_furn_dest = furn_dest - ms_shift;
9615 const time_duration fire_age = m.get_field_age( shifted_furn_pos, fd_fire );
9616 const int fire_intensity = m.get_field_intensity( shifted_furn_pos, fd_fire );
9617 m.remove_field( shifted_furn_pos, fd_fire );
9618 m.set_field_intensity( shifted_furn_dest, fd_fire, fire_intensity );
9619 m.set_field_age( shifted_furn_dest, fd_fire, fire_age );
9620 }
9621
9622 if( u.is_hauling() ) {
9623 start_hauling( oldpos );
9624 }
9625
9627
9628 return true;
9629}
void burn_move_stamina(int moves)
Definition: character.cpp:7214
virtual bool has_artifact_with(art_effect_passive effect) const
Definition: character.cpp:3209
units::mass get_weight() const override
Returns body weight plus weight of inventory and worn/wielded items.
Definition: character.cpp:3643
bool is_on_ground() const override
Returns true if the player is knocked over or has broken legs.
Definition: character.cpp:955
bool is_wearing(const itype_id &it) const
Returns true if the player is wearing the item.
Definition: character.cpp:3229
float mutation_value(const std::string &val) const
Goes over all mutations, gets min and max of a value with given name.
Definition: character.cpp:6742
int run_cost(int base_cost, bool diag=false) const
Returns the player's modified base movement cost.
m_size get_size() const override
Get size class of character.
Definition: character.cpp:534
bool grabbed_move(const tripoint &dp)
Check for dangerous stuff at dest_loc, return false if the player decides not to step there.
Definition: game.cpp:10235
bool is_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:9238
const string_id< T > & id() const
Definition: ammo_effect.cpp:33
int combined_movecost(const tripoint &from, const tripoint &to, const vehicle *ignored_vehicle=nullptr, int modifier=0, bool flying=false, bool via_ramp=false) const
Cost to move out of one tile and into the next.
Definition: map.cpp:1832
m_size get_size() const override
Definition: monster.cpp:2668
cata::optional< vpart_reference > part_displayed() const
Definition: vehicle.cpp:2498
bool is_stealthy() const
Returns true if the player has stealthy movement.
cata::optional< tripoint > last_target_pos
Definition: player.h:691
@ MS_TINY
Definition: creature.h:58
@ MS_LARGE
Definition: creature.h:61
@ MS_MEDIUM
Definition: creature.h:60
static const itype_id itype_rm13_armor_on("rm13_armor_on")
static const trait_id trait_M_IMMUNE("M_IMMUNE")
@ TFLAG_SMALL_PASSAGE
Definition: mapdata.h:320
@ TFLAG_HIDE_PLACE
Definition: mapdata.h:315
@ MF_LOUDMOVES
Definition: mtype.h:175
void fungus(player &p, const tripoint &examp)
Remove furniture.
Definition: iexamine.cpp:2146
void do_obstacle(const std::string &obst="")
Definition: sounds.cpp:1635
void do_footstep()
Definition: sounds.cpp:1612

References _, add_msg(), AEP_MOVEMENT_NOISE, AEP_STEALTH, cata_event_dispatch::avatar_moves(), Character::burn_move_stamina(), CMM_CROUCH, CMM_RUN, CMM_WALK, map::combined_movecost(), Character::dex_cur, sfx::do_footstep(), sfx::do_obstacle(), enumerate_as_string(), fd_fire, Character::footwear_factor(), iexamine::fungus(), map::furn(), get_dangerous_tile(), map::get_field_age(), map::get_field_intensity(), avatar::get_grab_type(), Character::get_size(), monster::get_size(), Character::get_weight(), avatar::grab(), player::grab_point, grabbed_move(), Character::has_artifact_with(), Character::has_bionic(), map::has_flag(), map::has_flag_ter(), map::has_flag_ter_or_furn(), map::has_furn(), Character::has_trait(), int_id< T >::id(), map::impassable(), Character::int_cur, is_dangerous_tile(), Character::is_hauling(), Character::is_mounted(), Character::is_on_ground(), player::is_stealthy(), Character::is_wearing(), itype_rm13_armor_on, player::last_target_pos, m, m_bad, m_good, m_warning, MAX_RECOIL, MF_LOUDMOVES, MF_RIDEABLE_MECH, Character::mod_fatigue(), Character::mounted_creature, map::move_cost(), map_data_common_t::movecost, sounds::movement, Character::movement_mode_is(), Creature::moves, MS_HUGE, MS_LARGE, MS_MEDIUM, MS_SMALL, MS_TINY, Character::mutation_value(), map::name(), cata::nullopt, int_id< T >::obj(), OBJECT_FURNITURE, OBJECT_NONE, OBJECT_VEHICLE, on_move_effects(), one_in(), optional_vpart_position::part_displayed(), place_player(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), prompt_dangerous_tile(), Character::recoil, map::remove_field(), Character::run_cost(), map::set_field_age(), map::set_field_intensity(), player::set_underwater(), sm_to_ms_copy(), sounds::sound(), start_hauling(), string_id< T >::str(), map::ter(), TFLAG_HIDE_PLACE, TFLAG_SMALL_PASSAGE, trait_M_IMMUNE, trait_PARKOUR, trigdist, tripoint_zero, u, map::veh_at(), veh_pointer_or_null(), vehicle::wheelcache, tripoint::x, tripoint::xy(), tripoint::y, and tripoint::z.

Referenced by swap_critters().

◆ wield() [1/2]

void game::wield ( )
private

Definition at line 9098 of file game.cpp.

9099{
9101
9102 if( loc ) {
9103 wield( loc );
9104 } else {
9105 add_msg( _( "Never mind." ) );
9106 }
9107}
item_location wield(avatar &you)
Item wielding/unwielding menu.

References _, add_msg(), u, wield(), and game_menus::inv::wield().

Referenced by handle_action(), inventory_item_menu(), and wield().

◆ wield() [2/2]

void game::wield ( item_location loc)
private

Definition at line 9010 of file game.cpp.

9011{
9012 if( u.is_armed() ) {
9013 const bool is_unwielding = u.is_wielding( *loc );
9014 const auto ret = u.can_unwield( *loc );
9015
9016 if( !ret.success() ) {
9017 add_msg( m_info, "%s", ret.c_str() );
9018 }
9019
9020 u.unwield();
9021
9022 if( is_unwielding ) {
9023 if( !u.martial_arts_data->selected_is_none() ) {
9024 u.martial_arts_data->martialart_use_message( u );
9025 }
9026 return;
9027 }
9028 }
9029
9030 const auto ret = u.can_wield( *loc );
9031 if( !ret.success() ) {
9032 add_msg( m_info, "%s", ret.c_str() );
9033 }
9034
9035 // Need to do this here because holster_actor::use() checks if/where the item is worn
9036 item &target = *loc.get_item();
9037 if( target.get_use( "holster" ) && !target.contents.empty() ) {
9038 //~ %1$s: weapon name, %2$s: holster name
9039 if( query_yn( pgettext( "holster", "Draw %1$s from %2$s?" ), target.get_contained().tname(),
9040 target.tname() ) ) {
9041 u.invoke_item( &target );
9042 return;
9043 }
9044 }
9045
9046 // Can't use loc.obtain() here because that would cause things to spill.
9047 item to_wield = *loc.get_item();
9048 item_location::type location_type = loc.where();
9049 tripoint pos = loc.position();
9050 int worn_index = INT_MIN;
9051 if( u.is_worn( *loc.get_item() ) ) {
9052 auto ret = u.can_takeoff( *loc.get_item() );
9053 if( !ret.success() ) {
9054 add_msg( m_info, "%s", ret.c_str() );
9055 return;
9056 }
9057 int item_pos = u.get_item_position( loc.get_item() );
9058 if( item_pos != INT_MIN ) {
9059 worn_index = Character::worn_position_to_index( item_pos );
9060 }
9061 }
9062 loc.remove_item();
9063 if( !u.wield( to_wield ) ) {
9064 switch( location_type ) {
9066 // this will not cause things to spill, as it is inside another item
9067 loc = loc.obtain( g->u );
9068 wield( loc );
9069 break;
9071 if( worn_index != INT_MIN ) {
9072 auto it = u.worn.begin();
9073 std::advance( it, worn_index );
9074 u.worn.insert( it, to_wield );
9075 } else {
9076 u.i_add( to_wield );
9077 }
9078 break;
9080 m.add_item( pos, to_wield );
9081 break;
9083 const cata::optional<vpart_reference> vp = m.veh_at( pos ).part_with_feature( "CARGO", false );
9084 // If we fail to return the item to the vehicle for some reason, add it to the map instead.
9085 if( !vp || !( vp->vehicle().add_item( vp->part_index(), to_wield ) ) ) {
9086 m.add_item( pos, to_wield );
9087 }
9088 break;
9089 }
9091 debugmsg( "Failed wield from invalid item location" );
9092 break;
9093 }
9094 return;
9095 }
9096}
std::list< item > worn
Definition: character.h:1571
static int worn_position_to_index(int position)
Definition: character.h:1137
item & i_add(item it, bool should_stack=true)
Definition: character.cpp:2317
ret_val< bool > can_unwield(const item &it) const
Check player capable of unwielding an item.
Definition: character.cpp:3144
bool wield(item &target) override
Removes currently wielded item (if any) and replaces it with the target item.
Definition: avatar.cpp:1210
type where() const
Returns the type of location where the item is found.
void remove_item()
Removes the selected item from the game.
tripoint position() const
Returns the position where the item is found.
const item & get_contained() const
Return a contained item (if any and only one).
Definition: item.cpp:6890
item & add_item(const tripoint &p, item new_item)
Place an item on the map, despite the parameter name, this is not necessarily a new item.
Definition: map.cpp:4313
ret_val< bool > can_wield(const item &it) const
Check player capable of wielding an item.
Definition: player.cpp:2491
bool unwield()
Definition: player.cpp:2530
ret_val< bool > can_takeoff(const item &it, const std::list< item > *res=nullptr)
Check player capable of taking off an item.
Definition: player.cpp:2953

References map::add_item(), add_msg(), player::can_takeoff(), Character::can_unwield(), player::can_wield(), item_location::character, item_location::container, item::contents, debugmsg, item_contents::empty(), g, item::get_contained(), item_location::get_item(), Character::get_item_position(), item::get_use(), Character::i_add(), item_location::invalid, avatar::invoke_item(), Character::is_armed(), Character::is_wielding(), Character::is_worn(), m, m_info, item_location::map, Character::martial_arts_data, item_location::obtain(), optional_vpart_position::part_with_feature(), pgettext(), item_location::position(), query_yn(), item_location::remove_item(), cata::hash64_detail::ret, item::tname(), u, player::unwield(), map::veh_at(), item_location::vehicle, item_location::where(), wield(), avatar::wield(), Character::worn, and Character::worn_position_to_index().

◆ win()

void game::win ( )

Marks the game as won.

Doesn't end the game.

Definition at line 2735 of file game.cpp.

2736{
2737 win_screen();
2739 memorial().add(
2740 pgettext( "memorial_male", "Closed the portal in %1$.1f days (%2$d seconds)." ),
2741 pgettext( "memorial_female", "Closed the portal in %1$.1f days (%2$d seconds)." ),
2742 to_days<float>( game_duration ), to_seconds<int>( game_duration ) );
2743 if( !u.is_dead_state() ) {
2746 }
2747}
void win_screen()
Definition: game.cpp:2749
void add(const std::string &male_msg, const std::string &female_msg)
Adds an event to the memorial log, to be written to the memorial file when the character dies.
const time_point & start_of_game
Definition: calendar.cpp:34

References achievements_tracker_ptr, memorial_logger::add(), Messages::display_messages(), get_kill_tracker(), player::is_dead_state(), memorial(), pgettext(), show_scores_ui(), calendar::start_of_game, stats(), calendar::turn, u, and win_screen().

◆ win_screen()

void game::win_screen ( )
private

Definition at line 2749 of file game.cpp.

2750{
2751 // TODO: Move this wall somewhere
2753 std::string msg = _( "You managed to close the portal and end the invasion!" );
2754 msg += '\n';
2755 if( u.is_dead_state() ) {
2757 "Unfortunately, you had to sacrifice your life to achieve this." );
2758 msg += colorize( t, c_red ) + '\n';
2759 memorial().add(
2760 pgettext( "memorial_male", "Sacrificed his life to close the portal." ),
2761 pgettext( "memorial_female", "Sacrificed her life to close the portal." ) );
2762 } else {
2763 translation t = translation::to_translation( "win_game", "You managed to survive the ordeal." );
2764 msg += colorize( t, c_green ) + '\n';
2765 memorial().add(
2766 pgettext( "memorial_male", "Safely closed the portal." ),
2767 pgettext( "memorial_female", "Safely closed the portal." ) );
2768 }
2769 msg += string_format( _( "It took you %1$.1f days (%2$d seconds)." ),
2770 to_days<float>( game_duration ), to_seconds<int>( game_duration ) );
2771 // TODO: Print starting stats, traits, skills, all mods ever used, easiest of settings
2772 popup( msg );
2773}
Class for storing translation context and raw string for deferred translation.
Definition: translations.h:152
static translation to_translation(const std::string &raw)
Store a string, an optional plural form, and an optional context for translation.
std::string colorize(const std::string &text, const nc_color &color)
Definition: color.cpp:669

References _, memorial_logger::add(), c_green, c_red, colorize(), player::is_dead_state(), memorial(), pgettext(), popup(), calendar::start_of_game, string_format(), translation::to_translation(), calendar::turn, and u.

Referenced by win().

◆ write_memorial_file()

void game::write_memorial_file ( const std::string &  filename,
std::string  sLastWords 
)

Writes information about the character out to a text file timestamped with the time of the file was made.

This serves as a record of the character's state at the time the memorial was made (usually upon death) and accomplishments in a human-readable format.

Definition at line 3138 of file game.cpp.

3139{
3140 const std::string &memorial_dir = PATH_INFO::memorialdir();
3141 const std::string &memorial_active_world_dir = memorial_dir +
3142 world_generator->active_world->world_name + "/";
3143
3144 //Check if both dirs exist. Nested assure_dir_exist fails if the first dir of the nested dir does not exist.
3145 if( !assure_dir_exist( memorial_dir ) ) {
3146 debugmsg( "Could not make '%s' directory", memorial_dir );
3147 return;
3148 }
3149
3150 if( !assure_dir_exist( memorial_active_world_dir ) ) {
3151 debugmsg( "Could not make '%s' directory", memorial_active_world_dir );
3152 return;
3153 }
3154
3155 std::string path = memorial_active_world_dir + filename + ".txt";
3156
3157 write_to_file( path, [&]( std::ostream & fout ) {
3158 memorial().write( fout, sLastWords );
3159 }, _( "player memorial" ) );
3160}
void write(std::ostream &memorial_file, const std::string &epitaph) const
std::string memorialdir()
Definition: path_info.cpp:226

References _, assure_dir_exist(), debugmsg, memorial(), PATH_INFO::memorialdir(), world_generator, memorial_logger::write(), and write_to_file().

Referenced by cleanup_at_end().

◆ zones_manager()

void game::zones_manager ( )

Definition at line 6364 of file game.cpp.

6365{
6366 const tripoint stored_view_offset = u.view_offset;
6367
6369
6370 const int zone_ui_height = 12;
6371 const int zone_options_height = 7;
6372
6373 const int width = 45;
6374
6375 int offsetX = 0;
6376 int max_rows = 0;
6377
6378 catacurses::window w_zones;
6379 catacurses::window w_zones_border;
6380 catacurses::window w_zones_info;
6381 catacurses::window w_zones_info_border;
6382 catacurses::window w_zones_options;
6383
6384 bool show = true;
6385
6386 ui_adaptor ui;
6387 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
6388 if( !show ) {
6389 ui.position( point_zero, point_zero );
6390 return;
6391 }
6392 offsetX = get_option<std::string>( "SIDEBAR_POSITION" ) != "left" ?
6393 TERMX - width : 0;
6394 const int w_zone_height = TERMY - zone_ui_height;
6395 max_rows = w_zone_height - 2;
6396 w_zones = catacurses::newwin( w_zone_height - 2, width - 2,
6397 point( offsetX + 1, 1 ) );
6398 w_zones_border = catacurses::newwin( w_zone_height, width,
6399 point( offsetX, 0 ) );
6400 w_zones_info = catacurses::newwin( zone_ui_height - zone_options_height - 1,
6401 width - 2, point( offsetX + 1, w_zone_height ) );
6402 w_zones_info_border = catacurses::newwin( zone_ui_height, width,
6403 point( offsetX, w_zone_height ) );
6404 w_zones_options = catacurses::newwin( zone_options_height - 1, width - 2,
6405 point( offsetX + 1, TERMY - zone_options_height ) );
6406
6407 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
6408 } );
6409 ui.mark_resize();
6410
6411 std::string action;
6412 input_context ctxt( "ZONES_MANAGER" );
6413 ctxt.register_cardinal();
6414 ctxt.register_action( "CONFIRM" );
6415 ctxt.register_action( "QUIT" );
6416 ctxt.register_action( "ADD_ZONE" );
6417 ctxt.register_action( "REMOVE_ZONE" );
6418 ctxt.register_action( "MOVE_ZONE_UP" );
6419 ctxt.register_action( "MOVE_ZONE_DOWN" );
6420 ctxt.register_action( "SHOW_ZONE_ON_MAP" );
6421 ctxt.register_action( "ENABLE_ZONE" );
6422 ctxt.register_action( "DISABLE_ZONE" );
6423 ctxt.register_action( "SHOW_ALL_ZONES" );
6424 ctxt.register_action( "HELP_KEYBINDINGS" );
6425
6426 auto &mgr = zone_manager::get_manager();
6427 int start_index = 0;
6428 int active_index = 0;
6429 bool blink = false;
6430 bool stuff_changed = false;
6431 bool show_all_zones = false;
6432 int zone_cnt = 0;
6433
6434 // get zones on the same z-level, with distance between player and
6435 // zone center point <= 50 or all zones, if show_all_zones is true
6436 auto get_zones = [&]() {
6437 std::vector<zone_manager::ref_zone_data> zones;
6438 if( show_all_zones ) {
6439 zones = mgr.get_zones();
6440 } else {
6441 const tripoint &u_abs_pos = m.getabs( u.pos() );
6442 for( zone_manager::ref_zone_data &ref : mgr.get_zones() ) {
6443 const tripoint &zone_abs_pos = ref.get().get_center_point();
6444 if( u_abs_pos.z == zone_abs_pos.z && rl_dist( u_abs_pos, zone_abs_pos ) <= 50 ) {
6445 zones.emplace_back( ref );
6446 }
6447 }
6448 }
6449 zone_cnt = static_cast<int>( zones.size() );
6450 return zones;
6451 };
6452
6453 auto zones = get_zones();
6454
6455 auto zones_manager_options = [&]() {
6456 werase( w_zones_options );
6457
6458 if( zone_cnt > 0 ) {
6459 const auto &zone = zones[active_index].get();
6460
6461 if( zone.has_options() ) {
6462 const auto &descriptions = zone.get_options().get_descriptions();
6463
6464 // NOLINTNEXTLINE(cata-use-named-point-constants)
6465 mvwprintz( w_zones_options, point( 1, 0 ), c_white, _( "Options" ) );
6466
6467 int y = 1;
6468 for( const auto &desc : descriptions ) {
6469 mvwprintz( w_zones_options, point( 3, y ), c_white, desc.first );
6470 mvwprintz( w_zones_options, point( 20, y ), c_white, desc.second );
6471 y++;
6472 }
6473 }
6474 }
6475
6476 wnoutrefresh( w_zones_options );
6477 };
6478
6479 cata::optional<tripoint> zone_start;
6480 cata::optional<tripoint> zone_end;
6481 bool zone_blink = false;
6482 bool zone_cursor = false;
6484 zone_start, zone_end, zone_blink, zone_cursor );
6485 add_draw_callback( zone_cb );
6486
6487 auto query_position =
6488 [&]() -> cata::optional<std::pair<tripoint, tripoint>> {
6489 on_out_of_scope invalidate_current_ui( [&]()
6490 {
6491 ui.mark_resize();
6492 } );
6493 restore_on_out_of_scope<bool> show_prev( show );
6494 restore_on_out_of_scope<cata::optional<tripoint>> zone_start_prev( zone_start );
6495 restore_on_out_of_scope<cata::optional<tripoint>> zone_end_prev( zone_end );
6496 show = false;
6497 zone_start = cata::nullopt;
6498 zone_end = cata::nullopt;
6499 ui.mark_resize();
6500
6502 popup.on_top( true );
6503 popup.message( "%s", _( "Select first point." ) );
6504
6506
6507 const look_around_result first = look_around( /*show_window=*/false, center, center, false, true,
6508 false );
6509 if( first.position )
6510 {
6511 popup.message( "%s", _( "Select second point." ) );
6512
6513 const look_around_result second = look_around( /*show_window=*/false, center, *first.position,
6514 true, true, false );
6515 if( second.position ) {
6516 tripoint first_abs = m.getabs( tripoint( std::min( first.position->x,
6517 second.position->x ),
6518 std::min( first.position->y, second.position->y ),
6519 std::min( first.position->z,
6520 second.position->z ) ) );
6521 tripoint second_abs = m.getabs( tripoint( std::max( first.position->x,
6522 second.position->x ),
6523 std::max( first.position->y, second.position->y ),
6524 std::max( first.position->z,
6525 second.position->z ) ) );
6526 return std::pair<tripoint, tripoint>( first_abs, second_abs );
6527 }
6528 }
6529
6530 return cata::nullopt;
6531 };
6532
6533 ui.on_redraw( [&]( const ui_adaptor & ) {
6534 if( !show ) {
6535 return;
6536 }
6537 zones_manager_draw_borders( w_zones_border, w_zones_info_border, zone_ui_height, width );
6538 zones_manager_shortcuts( w_zones_info );
6539
6540 if( zone_cnt == 0 ) {
6541 werase( w_zones );
6542 mvwprintz( w_zones, point( 2, 5 ), c_white, _( "No Zones defined." ) );
6543
6544 } else {
6545 werase( w_zones );
6546
6547 calcStartPos( start_index, active_index, max_rows, zone_cnt );
6548
6549 draw_scrollbar( w_zones_border, active_index, max_rows, zone_cnt, point_south );
6550 wnoutrefresh( w_zones_border );
6551
6552 int iNum = 0;
6553
6554 tripoint player_absolute_pos = m.getabs( u.pos() );
6555
6556 //Display saved zones
6557 for( auto &i : zones ) {
6558 if( iNum >= start_index &&
6559 iNum < start_index + ( ( max_rows > zone_cnt ) ? zone_cnt : max_rows ) ) {
6560 const auto &zone = i.get();
6561
6562 nc_color colorLine = ( zone.get_enabled() ) ? c_white : c_light_gray;
6563
6564 if( iNum == active_index ) {
6565 mvwprintz( w_zones, point( 0, iNum - start_index ), c_yellow, "%s", ">>" );
6566 colorLine = ( zone.get_enabled() ) ? c_light_green : c_green;
6567 }
6568
6569 //Draw Zone name
6570 mvwprintz( w_zones, point( 3, iNum - start_index ), colorLine,
6571 trim_by_length( zone.get_name(), 15 ) );
6572
6573 //Draw Type name
6574 mvwprintz( w_zones, point( 20, iNum - start_index ), colorLine,
6575 mgr.get_name_from_type( zone.get_type() ) );
6576
6577 tripoint center = zone.get_center_point();
6578
6579 //Draw direction + distance
6580 mvwprintz( w_zones, point( 32, iNum - start_index ), colorLine, "%*d %s",
6581 5, static_cast<int>( trig_dist( player_absolute_pos, center ) ),
6582 direction_name_short( direction_from( player_absolute_pos,
6583 center ) ) );
6584
6585 //Draw Vehicle Indicator
6586 mvwprintz( w_zones, point( 41, iNum - start_index ), colorLine,
6587 zone.get_is_vehicle() ? "*" : "" );
6588 }
6589 iNum++;
6590 }
6591
6592 // Display zone options
6593 zones_manager_options();
6594 }
6595
6596 wnoutrefresh( w_zones );
6597 } );
6598
6599 zones_manager_open = true;
6600 do {
6601 if( action == "ADD_ZONE" ) {
6602 do { // not a loop, just for quick bailing out if canceled
6603 const auto maybe_id = mgr.query_type();
6604 if( !maybe_id.has_value() ) {
6605 break;
6606 }
6607
6608 const zone_type_id &id = maybe_id.value();
6609 auto options = zone_options::create( id );
6610
6611 if( !options->query_at_creation() ) {
6612 break;
6613 }
6614
6615 auto default_name = options->get_zone_name_suggestion();
6616 if( default_name.empty() ) {
6617 default_name = mgr.get_name_from_type( id );
6618 }
6619 const auto maybe_name = mgr.query_name( default_name );
6620 if( !maybe_name.has_value() ) {
6621 break;
6622 }
6623 const std::string &name = maybe_name.value();
6624
6625 const auto position = query_position();
6626 if( !position ) {
6627 break;
6628 }
6629
6630 mgr.add( name, id, g->u.get_faction()->id, false, true, position->first,
6631 position->second, options );
6632
6633 zones = get_zones();
6634 active_index = zone_cnt - 1;
6635
6636 stuff_changed = true;
6637 } while( false );
6638
6639 blink = false;
6640 } else if( action == "SHOW_ALL_ZONES" ) {
6641 show_all_zones = !show_all_zones;
6642 zones = get_zones();
6643 active_index = 0;
6644 } else if( zone_cnt > 0 ) {
6645 if( action == "UP" ) {
6646 active_index--;
6647 if( active_index < 0 ) {
6648 active_index = zone_cnt - 1;
6649 }
6650 blink = false;
6651 } else if( action == "DOWN" ) {
6652 active_index++;
6653 if( active_index >= zone_cnt ) {
6654 active_index = 0;
6655 }
6656 blink = false;
6657 } else if( action == "REMOVE_ZONE" ) {
6658 if( active_index < zone_cnt ) {
6659 mgr.remove( zones[active_index] );
6660 zones = get_zones();
6661 active_index--;
6662
6663 if( active_index < 0 ) {
6664 active_index = 0;
6665 }
6666 }
6667 blink = false;
6668 stuff_changed = true;
6669
6670 } else if( action == "CONFIRM" ) {
6671 auto &zone = zones[active_index].get();
6672
6673 uilist as_m;
6674 as_m.text = _( "What do you want to change:" );
6675 as_m.entries.emplace_back( 1, true, '1', _( "Edit name" ) );
6676 as_m.entries.emplace_back( 2, true, '2', _( "Edit type" ) );
6677 as_m.entries.emplace_back( 3, zone.get_options().has_options(), '3',
6678 zone.get_type() == zone_type_id( "LOOT_CUSTOM" ) ? _( "Edit filter" ) : _( "Edit options" ) );
6679 as_m.entries.emplace_back( 4, !zone.get_is_vehicle(), '4', _( "Edit position" ) );
6680 // TODO: Enable moving vzone after vehicle zone can be bigger than 1*1
6681 as_m.entries.emplace_back( 5, !zone.get_is_vehicle(), '5', _( "Move position" ) );
6682 as_m.query();
6683
6684 switch( as_m.ret ) {
6685 case 1:
6686 if( zone.set_name() ) {
6687 stuff_changed = true;
6688 }
6689 break;
6690 case 2:
6691 if( zone.set_type() ) {
6692 stuff_changed = true;
6693 }
6694 break;
6695 case 3:
6696 if( zone.get_options().query() ) {
6697 stuff_changed = true;
6698 }
6699 break;
6700 case 4: {
6701 const auto pos = query_position();
6702 if( pos && ( pos->first != zone.get_start_point() ||
6703 pos->second != zone.get_end_point() ) ) {
6704 zone.set_position( *pos );
6705 stuff_changed = true;
6706 }
6707 break;
6708 }
6709 case 5: {
6710 on_out_of_scope invalidate_current_ui( [&]() {
6711 ui.mark_resize();
6712 } );
6713 restore_on_out_of_scope<bool> show_prev( show );
6714 restore_on_out_of_scope<cata::optional<tripoint>> zone_start_prev( zone_start );
6715 restore_on_out_of_scope<cata::optional<tripoint>> zone_end_prev( zone_end );
6716 show = false;
6717 zone_start = cata::nullopt;
6718 zone_end = cata::nullopt;
6719 ui.mark_resize();
6720 static_popup message_pop;
6721 message_pop.on_top( true );
6722 message_pop.message( "%s", _( "Moving zone." ) );
6723 const auto zone_local_start_point = m.getlocal( zone.get_start_point() );
6724 const auto zone_local_end_point = m.getlocal( zone.get_end_point() );
6725 // local position of the zone center, used to calculate the u.view_offset,
6726 // could center the screen to the position it represents
6727 auto view_center = m.getlocal( zone.get_center_point() );
6728 const look_around_result result_local = look_around( false, view_center,
6729 zone_local_start_point, false, false,
6730 false, true, zone_local_end_point );
6731 if( result_local.position ) {
6732 const auto new_start_point = m.getabs( *result_local.position );
6733 if( new_start_point == zone.get_start_point() ) {
6734 break; // Nothing changed, don't save
6735 }
6736
6737 const auto new_end_point = zone.get_end_point() - zone.get_start_point() + new_start_point;
6738 zone.set_position( std::pair<tripoint, tripoint>( new_start_point, new_end_point ) );
6739 stuff_changed = true;
6740 }
6741 }
6742 break;
6743 default:
6744 break;
6745 }
6746
6747 blink = false;
6748 } else if( action == "MOVE_ZONE_UP" && zone_cnt > 1 ) {
6749 if( active_index < zone_cnt - 1 ) {
6750 mgr.swap( zones[active_index], zones[active_index + 1] );
6751 zones = get_zones();
6752 active_index++;
6753 }
6754 blink = false;
6755 stuff_changed = true;
6756
6757 } else if( action == "MOVE_ZONE_DOWN" && zone_cnt > 1 ) {
6758 if( active_index > 0 ) {
6759 mgr.swap( zones[active_index], zones[active_index - 1] );
6760 zones = get_zones();
6761 active_index--;
6762 }
6763 blink = false;
6764 stuff_changed = true;
6765
6766 } else if( action == "SHOW_ZONE_ON_MAP" ) {
6767 //show zone position on overmap;
6768 tripoint_abs_omt player_overmap_position = u.global_omt_location();
6769 // TODO: fix point types
6770 tripoint_abs_omt zone_overmap( ms_to_omt_copy( zones[active_index].get().get_center_point() ) );
6771
6772 ui::omap::display_zones( player_overmap_position, zone_overmap, active_index );
6773 } else if( action == "ENABLE_ZONE" ) {
6774 zones[active_index].get().set_enabled( true );
6775
6776 stuff_changed = true;
6777
6778 } else if( action == "DISABLE_ZONE" ) {
6779 zones[active_index].get().set_enabled( false );
6780
6781 stuff_changed = true;
6782 }
6783 }
6784
6785 if( zone_cnt > 0 ) {
6786 blink = !blink;
6787 const auto &zone = zones[active_index].get();
6788 zone_start = m.getlocal( zone.get_start_point() );
6789 zone_end = m.getlocal( zone.get_end_point() );
6790 ctxt.set_timeout( BLINK_SPEED );
6791 } else {
6792 blink = false;
6793 zone_start = zone_end = cata::nullopt;
6794 ctxt.reset_timeout();
6795 }
6796
6797 // Actually accessed from the terrain overlay callback `zone_cb` in the
6798 // call to `ui_manager::redraw`.
6799 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
6800 zone_blink = blink;
6802
6804
6805 //Wait for input
6806 action = ctxt.handle_input();
6807 } while( action != "QUIT" );
6808 zones_manager_open = false;
6809 ctxt.reset_timeout();
6810 zone_cb = nullptr;
6811
6812 if( stuff_changed ) {
6813 auto &zones = zone_manager::get_manager();
6814 if( query_yn( _( "Save changes?" ) ) ) {
6815 zones.save_zones();
6816 } else {
6817 zones.load_zones();
6818 }
6819
6820 zones.cache_data();
6821 }
6822
6823 u.view_offset = stored_view_offset;
6824}
query_popup & on_top(bool top)
Whether to show the popup on the top of the screen.
Definition: popup.cpp:59
std::reference_wrapper< zone_data > ref_zone_data
Definition: clzones.h:345
static shared_ptr_fast< zone_options > create(const zone_type_id &type)
Definition: clzones.cpp:185
int trig_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:512
static void zones_manager_shortcuts(const catacurses::window &w_info)
Definition: game.cpp:6299
static void zones_manager_draw_borders(const catacurses::window &w_border, const catacurses::window &w_info_border, const int iInfoHeight, const int width)
Definition: game.cpp:6322
std::string options()
Definition: path_info.cpp:238
const std::set< itype_id > & get()
void display_zones(const tripoint_abs_omt &center, const tripoint_abs_omt &select, int iZoneIndex)
Display overmap like with display() and display the given zone.
std::string trim_by_length(const std::string &text, int width)
Definition: output.cpp:224
cata::optional< tripoint > position
Definition: game.h:127

References _, action, add_draw_callback(), BLINK_SPEED, c_green, c_light_gray, c_light_green, c_white, c_yellow, calcStartPos(), center, zone_options::create(), create_zone_callback(), direction_from(), direction_name_short(), ui::omap::display_zones(), draw_scrollbar(), uilist::entries, g, charge_removal_blacklist::get(), zone_manager::get_manager(), map::getabs(), map::getlocal(), Character::global_omt_location(), input_context::handle_input(), invalidate_main_ui_adaptor(), look_around(), m, query_popup::message(), ms_to_omt_copy(), mvwprintz(), om_direction::name(), catacurses::newwin(), cata::nullopt, query_popup::on_top(), PATH_INFO::options(), point_south, point_zero, popup(), Character::pos(), look_around_result::position, uilist::query(), query_yn(), ui_manager::redraw(), input_context::register_action(), input_context::register_cardinal(), input_context::reset_timeout(), uilist::ret, rl_dist(), second, input_context::set_timeout(), TERMX, TERMY, uilist::text, trig_dist(), trim_by_length(), tripoint_zero, u, player::view_offset, catacurses::werase(), catacurses::wnoutrefresh(), tripoint::z, zones_manager_draw_borders(), zones_manager_open, and zones_manager_shortcuts().

Referenced by handle_action().

◆ zoom_in()

void game::zoom_in ( )

Definition at line 7318 of file game.cpp.

7319{
7320#if defined(TILES)
7321 if( tileset_zoom == 64 ) {
7322 tileset_zoom = MAXIMUM_ZOOM_LEVEL;
7323 } else {
7325 }
7326 rescale_tileset( tileset_zoom );
7327#endif
7328}

References tileset_zoom.

Referenced by handle_action(), and look_around().

◆ zoom_out()

void game::zoom_out ( )

Definition at line 7306 of file game.cpp.

7307{
7308#if defined(TILES)
7309 if( tileset_zoom > MAXIMUM_ZOOM_LEVEL ) {
7311 } else {
7312 tileset_zoom = 64;
7313 }
7314 rescale_tileset( tileset_zoom );
7315#endif
7316}

References tileset_zoom.

Referenced by handle_action(), and look_around().

Friends And Related Function Documentation

◆ advanced_inventory

friend class advanced_inventory
friend

Definition at line 146 of file game.h.

◆ Creature_range

friend class Creature_range
friend

Definition at line 360 of file game.h.

Referenced by all_creatures().

◆ editmap

friend class editmap
friend

Definition at line 145 of file game.h.

◆ get_avatar

avatar & get_avatar ( )
friend

Definition at line 100 of file avatar.cpp.

101{
102 return g->u;
103}

◆ get_distribution_grid_tracker

distribution_grid_tracker & get_distribution_grid_tracker ( )
friend

Returns distribution grid tracker that is a part of the global game *g.

game TODO: This wouldn't be required in an ideal world

Definition at line 12581 of file game.cpp.

12582{
12583 return *g->grid_tracker_ptr;
12584}

◆ get_map

map & get_map ( )
friend

Definition at line 141 of file map.cpp.

142{
143 return g->m;
144}

Referenced by check_art_charge_req(), extended_description(), find_empty_spot_nearby(), get_fire_fuel_string(), and print_terrain_info().

◆ get_player_character

Character & get_player_character ( )
friend

Definition at line 381 of file character.cpp.

382{
383 return g->u;
384}

◆ get_weather

weather_manager & get_weather ( )
friend

Definition at line 64 of file weather.cpp.

65{
66 return *g->weather_manager_ptr;
67}

Referenced by do_turn(), get_player_input(), is_in_sunlight(), load(), natural_light_level(), place_player_overmap(), serialize_master(), setup(), start_game(), and unserialize_master().

◆ main_menu

friend class main_menu
friend

Definition at line 147 of file game.h.

◆ monster_range

friend class monster_range
friend

Definition at line 359 of file game.h.

Referenced by all_monsters().

Member Data Documentation

◆ achievements_tracker_ptr

pimpl<achievements_tracker> game::achievements_tracker_ptr
private

Definition at line 1003 of file game.h.

Referenced by death_screen(), game(), handle_action(), serialize(), setup(), unserialize(), and win().

◆ active_npc

◆ auto_travel_mode

bool game::auto_travel_mode = false

Definition at line 1066 of file game.h.

Referenced by handle_action(), serialize(), and unserialize().

◆ bVMonsterLookFire

bool game::bVMonsterLookFire = false
private

Definition at line 1083 of file game.h.

Referenced by list_monsters(), look_around(), and setup().

◆ coming_to_stairs

std::vector<monster> game::coming_to_stairs

◆ critter_died

bool game::critter_died = false
private

Has anything died in this turn and needs to be cleaned up?

Definition at line 1097 of file game.h.

Referenced by cleanup_dead(), and set_critter_died().

◆ critter_tracker

◆ debug_hour_timer

◆ debug_pathfinding

bool game::debug_pathfinding = false

Definition at line 1047 of file game.h.

◆ debug_submap_grid_overlay

bool game::debug_submap_grid_overlay = false

Definition at line 1048 of file game.h.

◆ destination_preview

std::vector<tripoint> game::destination_preview
private

◆ displaying_lighting_condition

int game::displaying_lighting_condition = 0

Type of lighting condition overlay to display.

Definition at line 1060 of file game.h.

◆ displaying_overlays

cata::optional<action_id> game::displaying_overlays
private

Definition at line 967 of file game.h.

Referenced by display_overlay_state(), and display_toggle_overlay().

◆ displaying_visibility_creature

Creature* game::displaying_visibility_creature

Creature for which to display the visibility map.

Definition at line 1058 of file game.h.

Referenced by display_visibility().

◆ draw_callbacks

std::vector<weak_ptr_fast<draw_callback_t> > game::draw_callbacks
private

Definition at line 251 of file game.h.

Referenced by add_draw_callback(), and draw().

◆ driving_view_offset

point game::driving_view_offset

Definition at line 1045 of file game.h.

Referenced by calc_driving_offset(), do_turn(), handle_action(), and set_driving_view_offset().

◆ event_bus_ptr

pimpl<event_bus> game::event_bus_ptr
private

Definition at line 1001 of file game.h.

Referenced by events().

◆ faction_manager_ptr

◆ first_redraw_since_waiting_started

bool game::first_redraw_since_waiting_started = true
private

Is this the first redraw since waiting (sleeping or activity) started.

Definition at line 1099 of file game.h.

Referenced by do_turn(), and game().

◆ follower_ids

std::set<character_id> game::follower_ids
private

◆ fullscreen

bool game::fullscreen = false

◆ gamemode

std::unique_ptr<special_game> game::gamemode
private

◆ grid_tracker_ptr

pimpl<distribution_grid_tracker> game::grid_tracker_ptr
private

Definition at line 1007 of file game.h.

Referenced by do_turn(), load_map(), on_options_changed(), and update_map().

◆ is_looking

bool game::is_looking = false
private

Definition at line 250 of file game.h.

Referenced by draw_ter(), and look_around().

◆ kill_tracker_ptr

pimpl<kill_tracker> game::kill_tracker_ptr
private

Definition at line 1004 of file game.h.

Referenced by game(), get_kill_tracker(), serialize(), setup(), and unserialize().

◆ last_mouse_edge_scroll

std::chrono::time_point<std::chrono::steady_clock> game::last_mouse_edge_scroll
private

Definition at line 1116 of file game.h.

Referenced by mouse_edge_scrolling().

◆ last_mouse_edge_scroll_vector_overmap

tripoint game::last_mouse_edge_scroll_vector_overmap
private

Definition at line 1118 of file game.h.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ last_mouse_edge_scroll_vector_terrain

tripoint game::last_mouse_edge_scroll_vector_terrain
private

Definition at line 1117 of file game.h.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ last_save_timestamp

time_t game::last_save_timestamp
private

Definition at line 1089 of file game.h.

Referenced by autosave(), init_autosave(), and quicksave().

◆ latest_lightlevels

std::array<float, OVERMAP_LAYERS> game::latest_lightlevels
mutableprivate

Definition at line 1090 of file game.h.

Referenced by natural_light_level(), and reset_light_level().

◆ list_item_downvote

std::string game::list_item_downvote
private

Definition at line 1080 of file game.h.

Referenced by list_items().

◆ list_item_upvote

std::string game::list_item_upvote
private

Definition at line 1079 of file game.h.

Referenced by list_items().

◆ liveview

live_view& game::liveview
private

Definition at line 998 of file game.h.

Referenced by draw_look_around_cursor(), and handle_mouseview().

◆ liveview_ptr

pimpl<live_view> game::liveview_ptr
private

Definition at line 997 of file game.h.

◆ m

map& game::m

Definition at line 1011 of file game.h.

Referenced by autopilot_vehicles(), cata_event_dispatch::avatar_moves(), butcher(), catch_a_monster(), check_near_zone(), check_zone(), control_vehicle(), disable_robot(), disp_NPCs(), do_turn(), draw(), draw_bullet(), draw_critter(), draw_critter_highlighted(), draw_critter_internal(), draw_hit_mon(), draw_look_around_cursor(), draw_ter(), examine(), extended_description(), find_nearby_items(), find_or_make_stairs(), fling_creature(), forced_door_closing(), get_cur_om(), get_dangerous_tile(), get_fishable_locations(), get_levx(), get_levy(), get_levz(), get_player_input(), get_veh_dir_indicator_location(), grabbed_furn_move(), grabbed_veh_move(), handle_action(), is_empty(), is_game_over(), is_in_sunlight(), is_sheltered(), knockback(), list_items(), list_monsters(), load(), load_map(), load_npcs(), look_around(), mon_info_update(), monmove(), moving_vehicle_dismount(), peek(), perhaps_add_random_npc(), phasing_move(), pickup(), place_critter_around(), place_player(), place_player_overmap(), place_vehicle_nearby(), pre_print_all_tile_info(), print_all_tile_info(), print_fields_info(), print_graffiti_info(), print_items_info(), print_terrain_info(), print_trap_info(), process_artifact(), prompt_dangerous_tile(), remoteveh(), save_cyborg(), save_maps(), serialize(), setup(), shift_monsters(), start_game(), start_hauling(), swap_critters(), try_get_left_click_action(), try_get_right_click_action(), update_map(), update_stair_monsters(), use_computer(), validate_camps(), validate_linked_vehicles(), validate_mounted_npcs(), vertical_move(), vertical_notes(), vertical_shift(), walk_move(), wield(), and zones_manager().

◆ main_ui_adaptor

weak_ptr_fast<ui_adaptor> game::main_ui_adaptor
private

◆ map_ptr

pimpl<map> game::map_ptr
private

Definition at line 995 of file game.h.

◆ memorial_logger_ptr

pimpl<memorial_logger> game::memorial_logger_ptr
private

Definition at line 1005 of file game.h.

Referenced by game(), and memorial().

◆ monstairz

int game::monstairz = 0

Definition at line 1032 of file game.h.

Referenced by update_stair_monsters(), and vertical_move().

◆ mostseen

int game::mostseen = 0

◆ moves_since_last_save

int game::moves_since_last_save = 0
private

Definition at line 1088 of file game.h.

Referenced by do_turn(), get_moves_since_last_save(), init_autosave(), quickload(), and quicksave().

◆ new_game

bool game::new_game = false

True if the game has just started or loaded, else false.

Definition at line 1028 of file game.h.

Referenced by do_turn(), setup(), and start_game().

◆ next_mission_id

int game::next_mission_id = 0
private

Definition at line 1086 of file game.h.

Referenced by assign_mission_id(), serialize_master(), setup(), and unserialize_master().

◆ next_npc_id

character_id game::next_npc_id
private

Definition at line 1084 of file game.h.

Referenced by assign_npc_id(), serialize_master(), setup(), and unserialize_master().

◆ npcs_dirty

bool game::npcs_dirty = false
private

Has a NPC been spawned since last load?

Definition at line 1095 of file game.h.

Referenced by do_turn(), load_npcs(), and set_npcs_dirty().

◆ queue_screenshot

bool game::queue_screenshot = false

Definition at line 1067 of file game.h.

Referenced by do_turn().

◆ remoteveh_cache

vehicle* game::remoteveh_cache
private

Definition at line 1093 of file game.h.

Referenced by remoteveh(), setremoteveh(), and setup().

◆ remoteveh_cache_time

time_point game::remoteveh_cache_time
private

Definition at line 1092 of file game.h.

Referenced by remoteveh(), setremoteveh(), and setup().

◆ right_sidebar

bool game::right_sidebar = false

Definition at line 1063 of file game.h.

◆ safe_mode

◆ safe_mode_warning_logged

bool game::safe_mode_warning_logged = false
private

Definition at line 1082 of file game.h.

Referenced by check_safe_mode_allowed(), handle_action(), and set_safe_mode().

◆ scen

const scenario* game::scen

Definition at line 1030 of file game.h.

Referenced by start_calendar(), and start_game().

◆ scent

scent_map& game::scent

Definition at line 1013 of file game.h.

Referenced by display_scent(), do_turn(), serialize(), setup(), unserialize(), update_map(), and vertical_shift().

◆ scent_ptr

pimpl<scent_map> game::scent_ptr
private

Definition at line 999 of file game.h.

◆ seed

unsigned int game::seed = 0
private

Seed for all the random numbers that should have consistent randomness (weather).

Definition at line 1111 of file game.h.

Referenced by get_seed(), serialize_master(), start_game(), and unserialize_master().

◆ sFilter

std::string game::sFilter
private

Definition at line 1078 of file game.h.

Referenced by list_items(), and reset_item_list_state().

◆ show_panel_adm

bool game::show_panel_adm = false

Definition at line 1062 of file game.h.

Referenced by draw_panels(), and load_static_data().

◆ spell_events_ptr

pimpl<spell_events> game::spell_events_ptr
private

Definition at line 1006 of file game.h.

Referenced by game(), and spell_events_subscriber().

◆ stats_tracker_ptr

pimpl<stats_tracker> game::stats_tracker_ptr
private

Definition at line 1002 of file game.h.

Referenced by game(), serialize(), stats(), and unserialize().

◆ ter_view_p

tripoint game::ter_view_p

Definition at line 1034 of file game.h.

Referenced by draw(), and draw_ter().

◆ tileset_zoom

int game::tileset_zoom = 0
private

How far the tileset should be zoomed out, 16 is default.

32 is zoomed in by x2, 8 is zoomed out by x0.5

Definition at line 1108 of file game.h.

Referenced by get_zoom(), look_around(), mouse_edge_scrolling_terrain(), reset_zoom(), set_zoom(), zoom_in(), and zoom_out().

◆ timed_event_manager_ptr

pimpl<timed_event_manager> game::timed_event_manager_ptr
private

Definition at line 1000 of file game.h.

◆ timed_events

timed_event_manager& game::timed_events

Definition at line 1014 of file game.h.

Referenced by do_turn(), natural_light_level(), and setup().

◆ token_provider_ptr

pimpl<drop_token_provider> game::token_provider_ptr

Definition at line 1023 of file game.h.

Referenced by serialize(), setup(), and unserialize().

◆ turnssincelastmon

int game::turnssincelastmon = 0

Definition at line 1069 of file game.h.

Referenced by handle_action(), mon_info_update(), and setup().

◆ u

avatar& game::u

Definition at line 1012 of file game.h.

Referenced by add_npc_follower(), autopilot_vehicles(), cata_event_dispatch::avatar_moves(), butcher(), calc_driving_offset(), cancel_activity_or_ignore_query(), cancel_activity_query(), catch_a_monster(), centerlistview(), chat(), check_safe_mode_allowed(), cleanup_at_end(), control_vehicle(), create_starting_npcs(), critter_at(), critter_by_id(), disable_robot(), disp_NPCs(), display_scent(), do_turn(), draw(), draw_critter(), draw_critter_highlighted(), draw_critter_internal(), draw_hit_mon(), draw_line(), draw_look_around_cursor(), draw_minimap(), draw_panels(), draw_ter(), draw_trail_to_square(), draw_veh_dir_indicator(), drop(), drop_in_direction(), exam_vehicle(), examine(), extended_description(), favorite_ammo_or_select(), find_nearby_items(), find_or_make_stairs(), fling_creature(), forced_door_closing(), fungal_effects::fungalize(), get_dangerous_tile(), get_player_base_save_path(), get_player_input(), get_veh_dir_indicator_location(), grabbed_furn_move(), grabbed_move(), grabbed_veh_move(), handle_action(), handle_key_blocking_activity(), inv_map_splice(), inventory_item_menu(), is_game_over(), is_hostile_within(), is_in_viewport(), item_action_menu(), knockback(), list_items(), list_items_monsters(), list_missions(), list_monsters(), load(), look_around(), mon_info(), mon_info_update(), monmove(), move_save_to_graveyard(), moving_vehicle_dismount(), npc_menu(), on_move_effects(), open_consume_item_menu(), open_gate(), overmap_npc_move(), peek(), perhaps_add_random_npc(), phasing_move(), pickup_feet(), place_player(), place_player_overmap(), print_all_tile_info(), print_creature_info(), print_items_info(), print_terrain_info(), print_trap_info(), process_activity(), process_artifact(), process_voluntary_act_interrupt(), prompt_dangerous_tile(), quickload(), reload(), reload_item(), reload_weapon(), reload_wielded(), remoteveh(), remove_npc_follower(), save(), save_player_data(), serialize(), set_driving_view_offset(), setremoteveh(), shared_from(), slip_down(), fungal_effects::spread_fungus_one_tile(), start_game(), start_hauling(), try_get_left_click_action(), try_get_right_click_action(), unload(), unserialize(), update_map(), update_overmap_seen(), update_stair_monsters(), use_computer(), validate_camps(), validate_npc_followers(), vertical_move(), vertical_notes(), vertical_shift(), walk_move(), wield(), win(), win_screen(), and zones_manager().

◆ u_ptr

pimpl<avatar> game::u_ptr
private

Definition at line 996 of file game.h.

◆ u_shared_ptr

shared_ptr_fast<player> game::u_shared_ptr
private

Definition at line 1073 of file game.h.

Referenced by shared_from().

◆ uquit

quit_status game::uquit

Used in main.cpp to determine what type of quit is being performed.

Definition at line 1026 of file game.h.

Referenced by cleanup_at_end(), do_turn(), get_player_input(), handle_action(), is_game_over(), and setup().

◆ user_action_counter

int game::user_action_counter = 0
private

Definition at line 1105 of file game.h.

Referenced by get_user_action_counter(), and handle_action().

◆ w_minimap

catacurses::window game::w_minimap

Definition at line 1038 of file game.h.

Referenced by create_or_get_main_ui_adaptor(), and draw_minimap().

◆ w_minimap_ptr

catacurses::window game::w_minimap_ptr
private

Definition at line 1076 of file game.h.

Referenced by create_or_get_main_ui_adaptor().

◆ w_omlegend

catacurses::window game::w_omlegend

Definition at line 1037 of file game.h.

◆ w_overmap

catacurses::window game::w_overmap

Definition at line 1036 of file game.h.

◆ w_pixel_minimap

catacurses::window game::w_pixel_minimap

◆ w_terrain

◆ w_terrain_ptr

catacurses::window game::w_terrain_ptr
private

Definition at line 1075 of file game.h.

Referenced by create_or_get_main_ui_adaptor().

◆ wait_popup

std::unique_ptr<static_popup> game::wait_popup
private

Definition at line 1124 of file game.h.

Referenced by do_turn().

◆ was_fullscreen

bool game::was_fullscreen = false

Definition at line 1065 of file game.h.

Referenced by load_static_data(), reenter_fullscreen(), and temp_exit_fullscreen().

◆ weather_manager_ptr

pimpl<weather_manager> game::weather_manager_ptr
private

Definition at line 1008 of file game.h.

◆ zones_manager_open

bool game::zones_manager_open = false
private

Is Zone manager open or not - changes graphics of some zone tiles.

Definition at line 1101 of file game.h.

Referenced by is_zones_manager_open(), and zones_manager().


The documentation for this class was generated from the following files: